豆约翰

豆约翰 查看完整档案

填写现居城市  |  填写毕业院校home  |  teacher 编辑 www.songbo.info 编辑
编辑

闲看庭前花开花落 漫随天外云卷云舒

个人动态

豆约翰 发布了文章 · 10月1日

Java零基础系列教程10Java抽象与封装

配套视频教程

本文B站配套视频教程

软件出现的目的

用计算机的语言描述现实世界
用计算机解决现实世界的问题

为什么使用面向对象

世界由对象组成

面向对象的思想 描述 面向对象的世界 符合人类思维习惯

image.png

从现实中抽象出类分三步:

  1. 找出它的种类
  2. 找出它的属性
  3. 找出它的行为

用面向对象描述世界

第一步:发现类
class Dog {

}
根据“对象”抽象出“类”

第二步:发现类的属性
狗类共有的特征:

  1. 品种
  2. 年龄
  3. 昵称
  4. 健康情况
  5. 跟主人的亲密度

… …

class Dog { 
    String name = "旺财"; // 昵称
    int health = 100; // 健康值    
    int love = 0;   // 亲密度
    String strain = "拉布拉多犬"; // 品种 
}
只放和业务相关的属性

第三步:发现类的方法
狗类共有的行为:

  1. 输出自己的信息

… …

class Dog { 
    String name = "旺财";   // 昵称
    int health = 100; // 健康值    
    int love = 0;     // 亲密度
    String strain = "拉布拉多犬"; // 品种 
    /* 输出狗的信息 */
    public void print() {
        // 输出狗信息的代码
    } 
}
只放和业务相关的方法

使用类图描述类

image.png

实践

实现领养宠物功能
编写宠物类Dog和Penguin
创建宠物对象,输入领养的宠物信息并输出
image.png

image.png

对象初始化

Penguin pgn = new Penguin();
pgn.name = "qq";
pgn.sex = "Q仔"; 
能否在创建对象的同时就完成赋值?

使用构造方法:
Penguin pgn1 = new Penguin();

class Penguin {
    // 属性
    /* 无参构造方法 */
    public Penguin() {
           name = "qq";
           love = 20;
           sex = "Q仔";
           System.out.println("执行构造方法");
    }
}

构造方法

image.png

系统提供默认无参构造方法
public Penguin() {

}

自定义构造方法

public Penguin () {
        name = "qq";
        love = 20;
        sex = "Q仔";
}
public Penguin (String name,int health,int love,String sex ) {
        this.name = name;
        this.health = health;
        this.love = love;
        this.sex = sex;
}
系统不再提供默认无参构造方法

this关键字是对一个对象的默认引用,这里用以区分同名成员变量

方法重载

image.png

System.out.println(45);
System.out.println(true);
System.out.println("狗在玩耍!"); 

调用重载方法

pgn = new Penguin();
pgn.print();
pgn = new Penguin("美美", 80, 20, "Q仔");
pgn.print();

一个例子

class Penguin {
       String name = null; //昵称
       int health = 0; // 健康值
       String sex = null; // 性别
       public void Penguin() {    
               health=10;
               sex="雄";
               System.out.println("执行构造方法");
        }
        public void print() {
               System.out.println("企鹅的名字是" + name + ",健康值是" 
                                                 + health + ",性别是" + sex);
        }
}
Penguin pgn3= new Penguin();
pgn3.print();

image.png

找出下面代码的问题

class Dog {
       private String name = "旺财";   // 昵称
       private int health = 100;  // 健康值    
       private int love = 0;     // 亲密度    
       public void play(int n) {
              int localv;
              health = health - n;        
              System.out.println(name+" "+ localv +" "+health+" "+love); 
       }
       public static void main(String[] args) {
              Dog d=new Dog();
              d.play(5);
       }
} 

static静态成员

一个例子 统计对象被创建出来的个数

class Person
{
    public String name;
    public int age;
    static public long  all_count;
    public Person(){
        all_count++;
    }
    public Person( String name , int age ){
        all_count++;
        this.name = name;
        this.age = age;
    }
    // 统计人数的函数
    public long getCount(){
      return all_count;
    }
    // 应该具备找同龄人的功能
    public boolean isSameAge( Person p1 ){
      return this.age == p1.age;
    }
}
class Demo9 
{
    public static void main(String[] args) 
    {
        Person p1 = new Person( "jame" ,  34 );
        Person p2 = new Person( "lucy" ,  34 );

        Person p3 = new Person( "lili" ,  34 );
        Person p4 = new Person();
        System.out.println( p1.getCount() + " " + p2.getCount() + "  " + p3.getCount()  );
        System.out.println( p1.isSameAge( p2 ) );
        System.out.println( p1.isSameAge( p3 ) );
    }
}

4:static特点
1 随着类的加载而加载,静态会随着类的加载而加载,随着类的消失而消失。说明它的生命周期很长。

      2 优先于对象存在。—>静态是先存在,对象是后存在。
     3 被所有实例(对象)所共享。
      4 可以直接被类名调用

image.png

使用static定义方法

用类名调用: Person.print();

静态方法只能访问静态属性,不能访问实例属性

找错误

class Dog {
       private String name = "旺财"; // 昵称
       private int health = 100;     // 健康值
       private int love = 0;        // 亲密度        
       public void play(int n) {
              static int localv=5;        
              health = health - n;        
              System.out.println(name+" "+localv+" "+health+" "+love);
       }    
       public static void main(String[] args) {
              Dog d=new Dog();
              d.play(5);
       }
} 

封装

Dog d = new Dog();
d.health = -1000;
属性随意访问,不合理的赋值

封装的概念

封装:将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问

封装的好处

1.隐藏类的实现细节
2.只能通过规定方法访问数据
3.方便加入控制语句
4.方便修改实现

封装的步骤

image.png

class Dog {
    private String name = "旺财"; // 昵称
    private int health = 100; // 健康值
    private int love = 0;   // 亲密度
    private String strain = "拉布拉多犬"; // 品种
    public int getHealth() {
        return health;
    }
    public void setHealth (int health) {
        if (health > 100 || health < 0) {
            this.health = 40;
            System.out.println("健康值应该在0和100之间,默认值是40");
        } else
            this.health  =  health;
    }
    // 其它getter/setter方法
}

this

用类名定义一个变量(对象,实例)的时候,定义的只是一个引用,外面可以通过这个引用来访问这个类里面的属性和方法。

那么类里面是够也应该有一个引用来访问自己的属性和方法呢?

JAVA提供了一个很好的东西,就是 this 对象,它可以在类里面来引用这个类的属性和方法。
先来个简单的例子:

public class ThisDemo {  
    String name="Mick";
    public void print(String name){
        System.out.println("类中的属性 name="+this.name);
        System.out.println("局部传参的属性="+name);
    }   
    public static void main(String[] args) {
        ThisDemo tt=new ThisDemo();
        tt.print("Orson");
    }
}

关于返回类自身的引用,《Thinking in Java》有个很经典的例子。
通过this 这个关键字返回自身这个对象然后在一条语句里面实现多次的操作

public class ThisDemo {  
    int number;
    ThisDemo increment(){
         number++;
         return this;
    }  
  private void print(){
         System.out.println("number="+number);
    }
    public static void main(String[] args) {
        ThisDemo tt=new ThisDemo();
         tt.increment().increment().increment().print();
    }
}

一个类中定义两个构造函数,在一个构造函数中通过 this 这个引用来调用另一个构造函数

public class ThisDemo {  
    String name;
    int age;
    public ThisDemo (){ 
        this.age=21;
   }     
    public ThisDemo(String name){
        this();
        this.name="Mick";
    }     
  private void print(){
         System.out.println("最终名字="+this.name);
         System.out.println("最终的年龄="+this.age);
    }
    public static void main(String[] args) {
       ThisDemo tt=new ThisDemo("zhangsan"); //随便传进去的参数
       tt.print();
    }
}

练习

创建Dog类
编写Test类

image.png

package com.company;

/**
 * Created by ttc on 2017/12/28.
 */
//private ,default, protected,public
public class Dog {
    private String name = "旺财"; // 昵称
    private int health = 100;     // 健康值0---100 private私有的
    private int love = 0;        // 亲密度
    private int type;//类型:1狗2企鹅
    private int kind;//品种

    public String toString()
    {
        String strKind = "";
        if(kind == 1)
        {
            strKind = "拉布拉多";
        }
        else if(kind == 2)
        {
            strKind = "雪纳瑞";
        }
        String str = "宠物的自白,我的名字叫"
                +name+"健康值是"+health+"和主人的亲密度是"+love+"我是一只"+strKind;
        return str;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public int getKind() {
        return kind;
    }

    public void setKind(int kind) {
        this.kind = kind;
    }
}

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("欢迎来到宠物店");
        System.out.println("请输入宠物名字");

        String name = scanner.next();

        System.out.println("请输入宠物类型:1狗,2企鹅");
        int type = scanner.nextInt();
        if(type == 1)
        {
            Dog d = new Dog();
            System.out.println("请输入品种,1聪明的拉布拉多,2酷酷的雪纳瑞");
            int kind = scanner.nextInt();
            d.setKind(kind);
            d.setName(name);
            System.out.println(d);
        }
        else
        {
            //new 企鹅();
        }

    }
}

创建Penguin类
编写Test类
image.png

查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程09java基础综合编程练习---猜单词游戏

配套视频教程

本文B站配套视频教程

image.png

任务目的

1.掌握字符串常用操作
2.掌握随机数的用法
3.掌握控制台基本输入输出
4.掌握循环,分支条件的用法
5.培养编程思维,提高分析问题能力`

任务描述

image.png

需求

给定单词数组(不少于10个),程序随机选择其中的一个,并显示单词字符长度个横线(-),用户有5次猜测机会,用户每次猜一个字母,如果正确,则将在相应的位置上显示出来;如错误则猜测机会减一,重复该过程,直至单词的全部字母全部猜出或者猜测次数用完,最后宣布用户胜利或失败。

实例

例如随机选出的单词是apple,程序先打印- - - - -
用户输入p,程序打印
-pp--
用户输入e,程序打印
-pp-e
用户输入t,程序打印
-pp-e
您还有4次机会
用户输入a,程序打印
app-e
用户输入l,程序打印
apple
恭喜您,取得胜利。

任务注意事项

请注意代码风格的整齐、优雅
代码中含有必要的注释

学习参考资料

百度以下java类型的用法:

  • Scanner
  • Random

参考答案

首先,鼓励大家先自己进行思考,然后再对照我们给出的参考答案。以达到提高自己分析问题的能力。
参考答案

public class MyGuessWord {

    public static void printWords(char[] wordNow)
    {
        for(int i = 0; i < wordNow.length; i++)
        {
            System.out.print(wordNow[i]);
        }
    }

    public static void main(String[] args) {
        //1随机从题库中挑出一个单词给用户猜
        //题库怎么表达---字符串数组
        String[] words = {"static","abstract","extends","implements","throw","orange","student","select","group","interface"};
        //随机选出一个单词
        Random random =  new Random();
        int randomIndex = random.nextInt(words.length);//随机下标

        String selectWord = words[randomIndex];
        System.out.println(selectWord);

        //定义一个字符数组保存用户当前单词的猜中部分
         char[] wordNow = new char[selectWord.length()];

         //将字符数组中的每个字符初始设置成-
        for(int i = 0; i < wordNow.length; i++)
        {
            wordNow[i] = '-';
        }

       printWords(wordNow);
        //2.向用户输出和选出单词同等数量的横线-
        //需要知道单词有多少个字符 selectWord.length()


       int userTimes = 5;//用户可以猜5次;
       //让用户开始猜,接受用户输入一个字符,判断用户输入的字符是否在单词中
        //如果不在,机会减一;如果猜对了,就在字符对应的位置将该字符显示出来

        //上述步骤循环执行,有2种情况跳出循环
        //1.用户猜出了单词的全部字符,用户赢了
        //2.用户的机会减为0了,用户输了
        while(true)
        {
            Scanner scanner = new Scanner(System.in);
            System.out.println();
            String strGuess = scanner.next();//用户输入的字符z
//        boolean bIsContains = selectWord.contains(strGuess);
            int nIndex = selectWord.indexOf(strGuess);//interface
            if(nIndex < 0)//如果不在,机会减一;输出还剩多少次机会,并且输出当前单词的猜中部分
            {
                userTimes--;
                if(userTimes == 0)
                {
                    break;
                }
                System.out.println("还剩"+userTimes+"次机会");
                printWords(wordNow);
            }
            else//如果猜对了,就在字符对应的位置将该字符显示出来,其他的位置依然打印-
            {
                //在字符对应的位置将该字符显示出来,其他的位置依然打印-(有可能该字符在单词中出现多次,都要变身)
                for(int i = 0; i < selectWord.length(); i++)
                {
                    //取出单词的每一个字符
                    char tempC = selectWord.charAt(i);
                    if(tempC == strGuess.charAt(0))
                    {
                        wordNow[i] = tempC;
                    }
                }

                printWords(wordNow);
                //如果wordNow数组中不在包含-,说明所有的字符全部被猜出来了
                String strWordNow = String.valueOf(wordNow);//字符数组转为字符串
                if(!strWordNow.contains("-"))
                {
                    break;
                }

            }
        }

        //判断最终结果
        //1.用户猜出了单词的全部字符,用户赢了
        //2.用户的机会减为0了,用户输了
        if(userTimes > 0)//说明不是因为机会没了跳出的循环
        {
            System.out.println("恭喜,你猜对啦");
        }
        else
        {
            System.out.println("你输了,正确答案是");
            System.out.println(selectWord);

        }
    }
}
查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程08Java字符串

配套视频教程

本文B站配套视频教程

String类位于java.lang包中,具有丰富的方法

字符串的初始化方法

/*
 * 字符串:就是由多个字符组成的一串数据。也可以看成是一个字符数组。
 * 通过查看API,我们可以知道
 *         A:字符串字面值"abc"也可以看成是一个字符串对象。
 *         B:字符串是常量,一旦被赋值,就不能被改变。
 * 
 * 初始化方法:
 *         public String():
 *        public String(String original):把字符串常量值转成字符串
 *
 * 字符串的方法:
 *         public int length():返回此字符串的长度。
 */
public class StringDemo {
    public static void main(String[] args) {
        // public String():
        String s1 = new String();
        System.out.println("s1:" + s1);
        System.out.println("s1.length():" + s1.length());
        System.out.println("--------------------------");
        //s1:
        //s1.length():0

      //public String(String original):把字符串常量值转成字符串
        String s6 = new String("abcde");
        System.out.println("s6:" + s6);
        System.out.println("s6.length():" + s6.length());
        System.out.println("--------------------------");
        
        //字符串字面值"abc"也可以看成是一个字符串对象。
        String s7 = "abcde";
        System.out.println("s7:"+s7);
        System.out.println("s7.length():"+s7.length());
    }
}
字符串的特点:一旦被赋值,就不能改变。
但是引用可以改变.
public class StringDemo {
    public static void main(String[] args) {
        String s = "hello";
        s += "world";
        System.out.println("s:" + s); // helloworld
    }
}

image.png

String s = new String(“hello”)和 String s = “hello”;的区别?
String字面值对象和构造方法创建对象的区别
/*
 * String s = new String(“hello”)和String s = “hello”;的区别?
 * 有。前者会创建2个对象,后者创建1个对象。
 * 
 * ==:比较引用类型比较的是地址值是否相同
 * equals:比较引用类型默认也是比较地址值是否相同,而String类重写了equals()方法,比较的是内容是否相同。
 */
public class StringDemo2 {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = "hello";

        System.out.println(s1 == s2);// false
        System.out.println(s1.equals(s2));// true
    }
}

image.png

 String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5 == s6);// 字符串字面量,直接从内存找,所以true
        System.out.println(s5.equals(s6));// true

String类的判断功能:

/*
 * String类的判断功能:
 * boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
 * boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
 * boolean contains(String str):判断大字符串中是否包含小字符串
 * boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
 * boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
 * boolean isEmpty():判断字符串是否为空。
 * 
 * 注意:
 *         字符串内容为空和字符串对象为空。
 *         String s = "";//对象存在,所以可以调方法
 *         String s = null;//对象不存在,不能调方法
 */
public class StringDemo {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "helloworld";
        String s2 = "helloworld";
        String s3 = "HelloWorld";

        // boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
        System.out.println("equals:" + s1.equals(s2));
        System.out.println("equals:" + s1.equals(s3));
        System.out.println("-----------------------");

        // boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println("equals:" + s1.equalsIgnoreCase(s2));
        System.out.println("equals:" + s1.equalsIgnoreCase(s3));
        System.out.println("-----------------------");

        // boolean contains(String str):判断大字符串中是否包含小字符串
        System.out.println("contains:" + s1.contains("hello"));
        System.out.println("contains:" + s1.contains("hw"));
        System.out.println("-----------------------");

        // boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
        System.out.println("startsWith:" + s1.startsWith("h"));
        System.out.println("startsWith:" + s1.startsWith("hello"));
        System.out.println("startsWith:" + s1.startsWith("world"));
        System.out.println("-----------------------");

        // 练习:boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩

        // boolean isEmpty():判断字符串是否为空。
        System.out.println("isEmpty:" + s1.isEmpty());

        String s4 = "";
        String s5 = null;
        System.out.println("isEmpty:" + s4.isEmpty());
        // NullPointerException
        // s5对象都不存在,所以不能调用方法,空指针异常
//        System.out.println("isEmpty:" + s5.isEmpty());
        
    }
}

String类的获取功能



/*
 * String类的获取功能
 * int length():获取字符串的长度。
 * char charAt(int index):获取指定索引位置的字符
 * int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
 *         为什么这里是int类型,而不是char类型?
 *         原因是:'a'和97其实都可以代表'a'。如果里面写char,就不能写数字97了
 * int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
 * int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
 * int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
 * String substring(int start):从指定位置开始截取字符串,默认到末尾。
 * String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
 */
public class StringDemo {
    public static void main(String[] args) {
        // 定义一个字符串对象
        String s = "helloworld";

        // int length():获取字符串的长度。
        System.out.println("s.length:" + s.length());//10
        System.out.println("----------------------");

        // char charAt(int index):获取指定索引位置的字符
        System.out.println("charAt:" + s.charAt(7));//
        System.out.println("----------------------");

        // int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
        System.out.println("indexOf:" + s.indexOf('l'));
        System.out.println("----------------------");

        // int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
        System.out.println("indexOf:" + s.indexOf("owo"));
        System.out.println("----------------------");

        // int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
        System.out.println("indexOf:" + s.indexOf('l', 4));
        System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
        System.out.println("indexOf:" + s.indexOf('l', 40)); // -1
        System.out.println("----------------------");

        // 自己练习:int indexOf(String str,int
        // fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

        // String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
        System.out.println("substring:" + s.substring(5));
        System.out.println("substring:" + s.substring(0));
        System.out.println("----------------------");

        // String substring(int start,intend):从指定位置开始到指定位置结束截取字符串。
        //包括start索引但是不包end索引
        System.out.println("substring:" + s.substring(3, 8));
        System.out.println("substring:" + s.substring(0, s.length()));
    }
}
根据身份证号解析出生日

字符串遍历:



/*
 * 需求:遍历获取字符串中的每一个字符
 * 
 * 分析:
 *         A:如何能够拿到每一个字符呢?
 *             char charAt(int index)
 *         B:我怎么知道字符到底有多少个呢?
 *             int length()
 */
public class StringTest {
    public static void main(String[] args) {
        // 定义字符串
        String s = "helloworld";
        for (int x = 0; x < s.length(); x++) {
            System.out.println(s.charAt(x));
        }
    }
}

统计大写字母,小写字母,数字在字符串中的个数



/*
 * 需求:统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
 * 举例:
 *         "Hello123World"
 * 结果:
 *         大写字符:2个
 *         小写字符:8个
 *         数字字符:3个
 * 
 * 分析:
 *         前提:字符串要存在
 *         A:定义三个统计变量
 *             bigCount=0
 *             smallCount=0
 *             numberCount=0
 *         B:遍历字符串,得到每一个字符。
 *             length()和charAt()结合
 *         C:判断该字符到底是属于那种类型的
 *             大:bigCount++
 *             小:smallCount++
 *             数字:numberCount++
 * 
 *             这道题目的难点就是如何判断某个字符是大的,还是小的,还是数字的。
 *             ASCII码表:
 *                 0    48
 *                 A    65
 *                 a    97
 *             虽然,我们按照数字的这种比较是可以的,但是想多了,有比这还简单的
 *                 char ch = s.charAt(x);
 * 
 *                 if(ch>='0' && ch<='9') numberCount++
 *                 if(ch>='a' && ch<='z') smallCount++
 *                 if(ch>='A' && ch<='Z') bigCount++
 *        D:输出结果。
 *
 * 练习:把给定字符串的方式,改进为键盘录入字符串的方式。
 */
public class StringTest2 {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "Hello123World";
        
        //定义三个统计变量
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        
        //遍历字符串,得到每一个字符。
        for(int x=0; x<s.length(); x++){
            char ch = s.charAt(x);
            
            //判断该字符到底是属于那种类型的,char类型会转成int类型
            if(ch>='a' && ch<='z'){
                smallCount++;
            }else if(ch>='A' && ch<='Z'){
                bigCount++;
            }else if(ch>='0' && ch<='9'){
                numberCount++;
            }
        }
        
        //输出结果。
        System.out.println("大写字母"+bigCount+"个");
        System.out.println("小写字母"+smallCount+"个");
        System.out.println("数字"+numberCount+"个");
    }
}

String的转换功能:



/*
 * String的转换功能:
 * byte[] getBytes():把字符串转换为字节数组。
 * char[] toCharArray():把字符串转换为字符数组。
 * static String valueOf(char[] chs):把字符数组转成字符串。
 * static String valueOf(int i):把int类型的数据转成字符串。
 *         注意:String类的valueOf方法可以把任意类型的数据转成字符串。
 * String toLowerCase():把字符串转成小写。
 * String toUpperCase():把字符串转成大写。
 * String concat(String str):把字符串拼接。
 */
public class StringDemo {
    public static void main(String[] args) {
        // 定义一个字符串对象
        String s = "JavaSE";

        // byte[] getBytes():把字符串转换为字节数组。
        byte[] bys = s.getBytes();
        for (int x = 0; x < bys.length; x++) {
            System.out.println(bys[x]);
        }
        System.out.println("----------------");

        // char[] toCharArray():把字符串转换为字符数组。
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("----------------");

        // static String valueOf(char[] chs):把字符数组转成字符串。
        String ss = String.valueOf(chs);
        System.out.println(ss);
        System.out.println("----------------");

        // static String valueOf(int i):把int类型的数据转成字符串。
        int i = 100;
        String sss = String.valueOf(i);
        System.out.println(sss);
        System.out.println("----------------");

        // String toLowerCase():把字符串转成小写。
        System.out.println("toLowerCase:" + s.toLowerCase());
        System.out.println("s:" + s);
        // System.out.println("----------------");
        // String toUpperCase():把字符串转成大写。
        System.out.println("toUpperCase:" + s.toUpperCase());
        System.out.println("----------------");

        // String concat(String str):把字符串拼接。
        String s1 = "hello";
        String s2 = "world";
        String s3 = s1 + s2;
        String s4 = s1.concat(s2);
        System.out.println("s3:"+s3);
        System.out.println("s4:"+s4);
    }
}

把一个字符串的首字母转成大写,其余为小写。(只考虑英文大小写字母字符)



/*
 * 需求:把一个字符串的首字母转成大写,其余为小写。(只考虑英文大小写字母字符)
 * 举例:
 *         helloWORLD
 * 结果:
 *         Helloworld
 * 
 * 分析:
 *         A:先获取第一个字符
 *         B:获取除了第一个字符以外的字符
 *         C:把A转成大写
 *         D:把B转成小写
 *         E:C拼接D
 */
public class StringTest {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "helloWORLD";

        // 先获取第一个字符
        String s1 = s.substring(0, 1);
        // 获取除了第一个字符以外的字符
        String s2 = s.substring(1);
        // 把A转成大写
        String s3 = s1.toUpperCase();
        // 把B转成小写
        String s4 = s2.toLowerCase();
        // C拼接D
        String s5 = s3.concat(s4);
        System.out.println(s5);

        // 优化后的代码
        // 链式编程
        String result = s.substring(0, 1).toUpperCase()
                .concat(s.substring(1).toLowerCase());
        System.out.println(result);
    }
}

String类的其他功能:

替换功能:
去除字符串两空格
按字典顺序比较两个字符串

//        去除字符串两端空格

        String name = "     ni hao ";
        System.out.println(name.trim());
        System.out.println(name.trim().length());
        System.out.println(name);
        System.out.println(name.length());
//        替换功能:
        String str2 ="hello world hello kitty";
        String strNew = str2.replace("hello","hehe");
        System.out.println(strNew);
        String strNewName = name.replace(" ","");
        System.out.println(strNewName);
//        按字典顺序比较两个字符串
          String s1 = "Lisi";
          String s2 = "lisi";

          System.out.println(s1.compareTo(s2));
          if(s1.compareToIgnoreCase(s2) > 0)
          {
              System.out.println("da");
          }
          else
          {
              System.out.println("小");
          }


/*
 * 需求:把数组中的数据按照指定个格式拼接成一个字符串
 * 举例:
 *         int[] arr = {1,2,3};    
 * 输出结果:
 *        "[1, 2, 3]"
 * 分析:
 *         A:定义一个字符串对象,只不过内容为空
 *         B:先把字符串拼接一个"["
 *         C:遍历int数组,得到每一个元素
 *         D:先判断该元素是否为最后一个
 *             是:就直接拼接元素和"]"
 *             不是:就拼接元素和逗号以及空格
 *         E:输出拼接后的字符串
 * 
 * 把代码用功能实现。
 */
public class StringTest2 {
    public static void main(String[] args) {
        // 前提是数组已经存在
        int[] arr = { 1, 2, 3 };

        // 写一个功能,实现结果
        String result = arrayToString(arr);
        System.out.println("最终结果是:" + result);
    }

    /*
     * 两个明确: 返回值类型:String 参数列表:int[] arr
     */
    public static String arrayToString(int[] arr) {
        // 定义一个字符串
        String s = "";

        // 先把字符串拼接一个"["
        s += "[";

        // 遍历int数组,得到每一个元素
        for (int x = 0; x < arr.length; x++) {
            // 先判断该元素是否为最后一个
            if (x == arr.length - 1) {
                // 就直接拼接元素和"]"
                s += arr[x];
                s += "]";
            } else {
                // 就拼接元素和逗号以及空格
                s += arr[x];
                s += ", ";
            }
        }

        return s;
    }
}

字符串反转



import java.util.Scanner;

/*
 * 字符串反转
 * 举例:键盘录入”abc”        
 * 输出结果:”cba”
 * 
 * 分析:
 *         A:键盘录入一个字符串
 *         B:定义一个新字符串
 *         C:倒着遍历字符串,得到每一个字符
 *             a:length()和charAt()结合
 *             b:把字符串转成字符数组
 *         D:用新字符串把每一个字符拼接起来
 *         E:输出新串
 */
public class StringTest3 {
    public static void main(String[] args) {
        // 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String line = sc.nextLine();

        String s = myReverse(line);
        System.out.println("实现功能后的结果是:" + s);
    }

    /*
     * 两个明确: 返回值类型:String 参数列表:String
     */
    public static String myReverse(String s) {
        // 定义一个新字符串
        String result = "";

        // 把字符串转成字符数组
        char[] chs = s.toCharArray();

        // 倒着遍历字符串,得到每一个字符
        for (int x = chs.length - 1; x >= 0; x--) {
            // 用新字符串把每一个字符拼接起来
            result += chs[x];
        }
        return result;
    }
}

字符串拆分

有一段歌词,每句都以空格“ ”结尾,请将歌词每句按行输出

image.png

String类提供了split()方法,将一个字符串分割为子字符串,结果作为字符串数组返回

public class Lyric {
        public static void main(String[] args) {
            String words="长亭外 古道边 芳草碧连天 晚风扶 柳笛声残 夕阳山外山";
            String[    ] printword=new String[100];        
               System.out.println("***原歌词格式***\n"+words);
            System.out.println("\n***拆分后歌词格式***");
            printword=words.split(" "); 
            for(int i=0;i<printword.length;i++){
                System.out.println( printword[i] );
            }
        }
}

统计大串中小串出现的次数



/*
 * 统计大串中小串出现的次数
 * 举例:
 *         在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
 * 结果:
 *         java出现了5次
 * 
 * 分析:
 *         前提:是已经知道了大串和小串。
 * 
 *         A:定义一个统计变量,初始化值是0
 *         B:先在大串中查找一次小串第一次出现的位置
 *             a:索引是-1,说明不存在了,就返回统计变量
 *             b:索引不是-1,说明存在,统计变量++
 *         C:把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
 *         D:回到B
 */
public class StringTest5 {
    public static void main(String[] args) {
        // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
        // 定义小串
        String minString = "java";

        // 写功能实现
        int count = getCount(maxString, minString);
        System.out.println("Java在大串中出现了:" + count + "次");
    }

    /*
     * 两个明确: 返回值类型:int 参数列表:两个字符串
     */
    public static int getCount(String maxString, String minString) {
        // 定义一个统计变量,初始化值是0
        int count = 0;        
        int index;
        //先查,赋值,判断
        while((index=maxString.indexOf(minString))!=-1){
            count++;
            maxString = maxString.substring(index + minString.length());
        }

        return count;
    }
}

解法2

  // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
        // 定义小串
        String minString = "java";
        String[] array = maxString.split(minString);
         System.out.println("Java在大串中出现了:" + (array.length -1) + "次");

StringBuffer和StringBuilder

对字符串频繁修改(如字符串连接)时,使用StringBuffer类可以大大提高程序执行效率

StringBuffer声明
StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer("aaa");
StringBuffer的使用
sb.toString(); //转化为String类型
sb.append("aaa"); //追加字符串

将一个数字字符串转换成逗号分隔的数字串,即从右边开始每三个数字用逗号分隔

image.png

查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程07Java有参方法和包

配套视频教程

本文B站配套视频教程

为什么要用带参数的方法

image.png
定义带参数的方法

参数列表:
(数据类型 参数1,数据类型 参数2…)

public class ZhazhiJi {
    public String zhazhi ( String fruit ) {
          String juice = fruit + "汁";
          return juice; 
     } 
}

调用带参数的方法

/*调用zhazhi方法*/
ZhazhiJi myZhazhiji = new ZhazhiJi();
String myFruit = "苹果";
String myJuice = myZhazhi.zhazhi(myFruit);
System.out.println(myJuice);

调用方法,传递的参数要与参数列表一一对应

image.png

定义带参数的方法

<访问修饰符> 返回类型 <方法名>(<形式参数列表>) {

      //方法的主体

}
调用带参数的方法
对象名.方法名(参数1, 参数2,……,参数n)

public class StudentsBiz {
    String[] names = new String[30];
    int index = 0;//记录数组中学员的个数,也就是下一个需要插入数组的下标位置
    public void addName(String name)
    {
        names[index] = name;
        index++;
    }
    public void showNames()
    {
        for(int i = 0; i < index; i++)
        {
            System.out.println(names[i]);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        StudentsBiz studentsBiz = new StudentsBiz();
        for(int i = 0; i < 3; i++)
        {
            System.out.println("请输入姓名");
            String name = scanner.next();
            studentsBiz.addName(name);
        }
        studentsBiz.showNames();
    }
}

带多个参数的方法

在保存了多个学生姓名的数组中,指定查找区间,查找某个学生姓名并显示是否查找成功

设计方法,通过传递三个参数(开始位置、结束位置、查找的姓名)来实现

public class StudentsBiz {
    String[] names = {"zhangsan","lisi","wangwu","liudehua"};

    public boolean searchName(String name,int start, int end)
    {
        if(end > names.length)
        {
            end = names.length;
        }
        if(start < 0)
        {
            start = 0;
        }

        for(int i = start; i < end; i++)
        {
            if(names[i].equals(name))
            {
                return true;
            }
        }

        return false;
    }
}

调用方法

public class Main {

    public static void main(String[] args) {
    // write your code here
//         zhangsan,lisi,wangwu,zhaobensan,liudehua
        StudentsBiz studentsBiz = new StudentsBiz();
        boolean b = studentsBiz.searchName("liudehua2",-5,8);
        System.out.println(b);
    }
}

数组作为参数的方法

有5位学员参加了Java知识竞赛的决赛,输出决赛的平均成绩和最高成绩
image.png
将5位学员的决赛成绩保存在数组中
设计求平均成绩、最高成绩的方法,并把数组作为参数

public class ScoreCalc {

    public int getTotalScore(int[] scores)
    {
        int totalScore = 0;
        for(int i = 0; i < scores.length; i++)
        {
            totalScore += scores[i];
        }
        return totalScore;
    }

    public double getAvgScore(int[] scores)
    {
        int totalScore = getTotalScore(scores);
        return (double) totalScore/scores.length;
    }

    public int getMaxScore(int[] scores)
    {
        int max = scores[0];//假设数组的第一个元素是最大
        for(int i = 1; i < scores.length; i++)
        {
            if(max < scores[i])
            {
                max = scores[i];
            }
        }

        return max;
    }
}
public class Main {

    public static void main(String[] args) {
    // write your code here
        ScoreCalc scoreCalc = new ScoreCalc();
        int[] arrays = {67,76,88,86,99};
        int total = scoreCalc.getTotalScore(arrays);
        System.out.println(total);
        double avg = scoreCalc.getAvgScore(arrays);
        System.out.println(avg);

        int max = scoreCalc.getMaxScore(arrays);
        System.out.println(max);
    }
}

对象作为参数的方法

在实现了增加一个学生姓名的基础上,增加学生的学号、年龄和成绩,并显示这些信息,如何实现?

image.png
方式一:设计带四个参数(学号、姓名、年龄、成绩)的方法
方式二:将学生学号、姓名、年龄、成绩封装在学生对象中,设计方法,以学生对象作为参数

可以将多个相关的信息封装成对象,作为参数传递,避免方法有太多的参数!
public class Student {
    int no;//学号
    int age;
    String name;
    int score;

    public String toString()
    {
        String info =  "学号" + no + "年龄" + age + "姓名" + name;
        return info;
    }
}
public class School {
    Student[] students = new Student[30];
    int index = 0;//当前数组中有多少个学生,也就是数组下一个要插入的下标位置
    public void addStudent(Student student)
    {
        students[index] = student;
        index++;
    }

    public void showStudents()
    {
        for(int i = 0; i < index; i++)
        {
            System.out.println(students[i]);
        }
    }
//    public void addStudent(String name, int no,int age, int score,int height)
//    {
//
//    }
}
public class Main {

    public static void main(String[] args) {
    // write your code here
        School school = new School();
        Student student = new Student();
        student.name = "zhangsan";
        student.no = 10;
        student.age = 23;
        student.score = 90;
        school.addStudent(student);
        school.showStudents();
    }
}

为什么需要包

Windows树形文件系统
文档分门别类,易于查找和管理
使用目录解决文件同名冲突问题
image.png

如何存放两个同名的类而不冲突?
image.png

image.png

 //声明包,作为Java源代码第一条语句,
//用package声明包,以分号结尾
//com.company.model是包名
package com.company.model;  
          
public class School {
    //……
    public String toString() {
       //……
    }
}

包命名规范

包名由小写字母组成,不能以圆点开头或结尾
包名之前最好加上唯一的前缀,通常使用组织倒置的网络域名
package net.javagroup.mypackage;
包名后续部分依不同机构内部的规范不同而不同

用intelij创建包和类

包与目录的关系

创建好的包和Java源文件是如何存储的?
创建包cn.company.classandobject ,
即创建了目录结构:cncompanyclassandobject
image.png

如何导入包

为了使用不在同一包中的类,需要在Java程序中使用import关键字导入这个类


import java.util.*;      //导入java.util包中所有类
import cn.company.classandobject.School;    //导入指定包中指定类

image.png

本节练习

模拟银行账户业务

创建包bank.com,
编写Account类,添加带参
方法实现存款和取款业务,
存款时帐户初始金额为0元,
取款时如果余额不足给出提示

image.png

package com.bank;

/**
 * Created by ttc on 2017/12/26.
 */
//账户
public class Account {
    public int money;//账户余额

    //存钱
    public void saveMoney(int value)
    {
        money += value;
        System.out.println("存款成功");
    }

    //取钱
    public void getMoney(int value)
    {
        if(money < value)
        {
            System.out.println("余额不足");
            return;
        }
        money -= value;
        System.out.println("取款成功");
    }
    //显示当前余额
    public void showMoney()
    {
        System.out.println("当前余额为:" + money);
    }
}
public class Main {

    public static void main(String[] args) {
    // write your code here

        Scanner scanner = new Scanner(System.in);
        int command = 0;//命令
        //初始化账户对象
        Account account = new Account();

        while (true)
        {
            System.out.println("1 存款 2 取款 0 退出");
            System.out.println("请选择要办理的业务");
            command = scanner.nextInt();

            if(command == 1)//存款
            {
                System.out.println("请输入金额");
                //获取用户输入的金额
                int value = scanner.nextInt();
                account.saveMoney(value);
                account.showMoney();
            }
            else if(command == 2)
            {
                System.out.println("请输入金额");
                //获取用户输入的金额
                int value = scanner.nextInt();
                account.getMoney(value);
                account.showMoney();

            }
            else if(command == 0)
            {
                break;
            }
            else
            {
                System.out.println("错误的命令");
            }
        }

        System.out.println("程序退出");
    }
}
查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程06Java初识类和对象

配套视频教程

本文B站配套视频教程

万物皆对象

image.png

分类是人们认识世界的一个很自然的过程,在日常生活中会不自觉地进行分类

身边的对象

image.png

顾客

姓名—张浩
年龄—20
体重—60kg

操作:
购买商品

image.png

收银员

员工号—10001
姓名—李明
部门—财务部

操作:
收款
打印账单

对象的特征——属性

属性——对象具有的各种特征
每个对象的每个属性都拥有特定值
例如:张浩和李明的年龄、姓名不一样
image.png

对象的特征——方法(操作,行为)

方法——对象执行的操作(通常会改变属性的值)
image.png

对象:用来描述客观事物的一个实体,由一组属性和方法构成

例子

image.png
属性:
品牌:法拉利
型号:F360 Spider
颜色:黄色
价格:380万元
方法:
发动
停止
加速
image.png

属性:
颜色:白色
方法:


对象同时具有属性和方法两项特性
对象的属性和方法通常被封装在一起,共同体现事物的特性, 二者相辅相承,不能分割

说一说教室里的对象
描述他们的属性和方法

从对象抽象出“类”

抽取出下列对象的共同特征(属性和方法)
image.png

image.png

类是模子,定义对象将会拥有的特征(属性)和行为(方法)

类是对象的类型
不同于int类型:具有方法

  • 类是抽象的概念,仅仅是模板

比如说:“人”

  • 对象是一个你能够看得到、摸得着的具体实体

赵本山,刘德华,赵丽颖

image.png

所有Java程序都以类class为组织单元

关键字class定义自定义的数据类型

public class  类名 {
        //定义属性部分
        属性1的类型 属性1;
        属性2的类型 属性2;
      …
        属性n的类型 属性n;
        //定义方法部分
        方法1;
        方法2;
        …
        方法m;
}

定义一个类的步骤

  1. 定义类名
  2. 编写类的属性
  3. 编写类的方法

在不同城市的培训中心,会感受到相同的环境和教学氛围,用类的思想输出中心信息
image.png

public class School {
    String schoolName;        //中心名称
    int classNumber;        //教室数目
    int labNumber;            //机房数目
    
    
    public void showCenter() {
        System.out.println(schoolName + "培训学员\n" + "配备:" 
            + classNumber + "教" + labNumber + "机");
    }
}

使用对象的步骤

创建对象
类名 对象名 = new 类名();

School center = new School();

引用对象成员:使用“.”进行以下操作
引用类的属性:对象名.属性
引用类的方法:对象名.方法名()

center.name = "北京中心";    //给name属性赋值
center.showCenter();         //调用showCenter()方法
public class InitialSchool {
    public static void main(String[] args) {
        School center = new School();
        System.out.println("***初始化成员变量前***");
        center. showCenter();//看到什么效果?

        center.schoolName = "北京中心";        
        center.classNumber = 10;                
        center.labNumber = 10;                
        System.out.println("\n***初始化成员变量后***");
        center.showCenter()/看到什么效果?
    }
}

编写学员类,输出学员相关信息
编写教员类,输出教员相关信息
image.png

一个景区根据游人的年龄收取不同价格的门票。请编写游人类,根据年龄段(10岁到60岁之间20元,否则免费)决定能够购买的门票价格并输出
package com.company;

/**
 * Created by ttc on 17-12-25.
 */
public class JourneyPerson {
    String name;
    int age;

    public void showInfo()
    {
        String ticketInfo = "";
        if(age < 10 || age > 60)
        {
            ticketInfo = "门票免费";
        }
        else
        {
            ticketInfo = "门票价格为:20元";
        }

        System.out.println(name + "的年龄为:"+ age + ticketInfo);
    }
}
package com.company;


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
    // write your code here
        JourneyPerson journeyPerson = new JourneyPerson();

        while (true)
        {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入姓名,输入n退出程序");
            //创建一个游人类

            //将用户输入的姓名,赋值给游人对象journeyPerson的名字属性
            journeyPerson.name = scanner.next();
            if(journeyPerson.name.equals("n"))//代表用户想退出程序
            {
                // 退出程序
                break;
            }

            //将用户输入的年龄,赋值给游人对象journeyPerson的年龄属性
            System.out.println("请输入年龄");
            journeyPerson.age = scanner.nextInt();

            //输出该游人门票信息和个人信息showInfo
            journeyPerson.showInfo();
        }

        System.out.println("退出程序");

    }
}

image.png

类的方法

电动玩具狮子
属性:
颜色:黄色

行为:

image.png

定义类的方法

public 返回值类型 方法名() {

       //这里编写方法的主体

}

两种情况

  • 如果方法具有返回值,方法体中必须使用关键字return返回该值,返回值类型为该返回值的类型

return 表达式;
作用: 跳出方法、返回结果

public class Student{
    String name = "张三";
    public String  getName(){
            return name;
    }
   //……
}
  • 如果方法没有返回值,返回值类型为void
public class Student{
    String name = "张三";
    public void getName(){
            
    }
   //……
}
方法是个“黑匣子”(不必关注其内部如何实现功能),完成某个特定的应用程序功能,并返回结果
香肠加工厂

image.png

方法调用:执行方法中包含的语句

对象名.方法名();

public class AutoLion {  
    String color = "黄色";  //颜色
    /*跑*/
    public void run(){
        System.out.println("正在以0.1米/秒的速度向前奔跑。");
     }
    /*叫*/
     public String bark(){
         String sound = "大声吼叫" ; 
         return sound;
     } 
    /*获得颜色*/
    public String getColor(){
         return color;
    }
    /*显示狮子特性*/
    public String showLion(){
        return "这是一个" + getColor() + "的玩具狮子!";
    }
}

调试观察

public class TestLion {
    public static void main(String[ ] args) {
           AutoLion lion = new AutoLion();
           System.out.println(lion.showLion());     
           lion.run();
           System.out.println(lion.bark());
     }
}

方法之间允许相互调用,不需要知道方法的具体实现,实现重用,提高效率
image.png

常见错误

public class Student1 {
    public void  showInfo() {
           return  "我是一名学生";
        }
}

方法的返回值类型为void,方法中不能有return 返回值!

public class Student2 {
    public double getInfo() {
           double weight = 95.5;
           double height = 1.69;
         return weight, height;
        }
}

方法不能返回多个值!

public class Student3 {
    public String showInfo() {
    
        public double getInfo() {
                 double weight = 95.5;
                 double height = 1.69;
                   return weight;
             }
                return "我是一名学生";
         }
}

多个方法不能相互嵌套定义!

public class Student4 {
    int age = 20;
    if(age < 20) {
        System.out.println("年龄不符合入学要求!");  
    }
    public void showInfo() {
        return "我是一名学生";
    }
}

不能在方法外部直接写程序逻辑代码!

模拟骰子

public class Dice {
    int[] value = new int[6];

    //初始化
    public void init()
    {
        for(int i = 0; i < 6; i++)
        {
            value[i] = i+1;
        }
    }

    //抛骰子
    public int throwDice()
    {
        //生成一个随机数组下标[0-6)之间的数
        int index = (int)(Math.random()*6);
        return value[index];
    }
}

测试类

package com.company;

/**
 * Created by ttc on 17-12-22.
 */
public class TestDice {
//    复用..
    public static void main(String[] args) {
        //用来计数1-6之间的数一共出现了几次的一个数组
        int[] count = new int[7];

        Dice dice = new Dice();//创建 一个骰子对象(6个面都是0)
        dice.init();//初始化骰子对象,把6个面都赋上值
        //模拟抛600000次骰子
        for(int i = 0; i < 60; i++)
        {
            int num = dice.throwDice();//本次骰子的点数(1-6)之间的数
            //把点数作为下标,代入到count数组中,将count[num]对应的值+1(记录num出现的次数)
            // count[num]当前的值,保存着num已经出现了多少次这个信息
            count[num]++;
//            System.out.println(num);
        }

        //最终对count数组遍历,
        for(int i = 1; i < count.length; i++)
        {
            //count[i]里保存着i出现了多少次
            System.out.println(i+"出现了" +count[i]+"次");
        }

    }

}

从键盘接收三门课分数,计算三门课的平均分和总成绩,编写成绩计算类实现功能
  1. 创建类 ScoreCalc
  2. 编写方法实现各功能
  3. 编写测试类

变量的作用域

变量声明的位置决定变量作用域
变量作用域确定可在程序中按变量名访问该变量的区域

//…
for(int  a = 0; a < 4; a++) {
     System.out.println ("hello" );
}
System.out.println ( a );
//…

成员变量和局部变量

谁能使用这些变量?
image.png

作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
初始值不同
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值

在同一个方法中,不允许有同名局部变量,在不同的方法中,可以有同名局部变量

在同一个类中,成员变量和局部变量同名时,局部变量具有更高的优先级

public class Test {
     int score1 = 88;
     int score2 = 98;
      public void calcAvg() {
          int avg = (score1 + score2)/2;
      }    
      public void showAvg(){
         System.out.println("平均分是: " + avg);
     }
}

局部变量avg的作用域仅限于calcAvg()方法

面向对象编程

输入三门课的成绩,计算并打印平均成绩和总成绩
public static void main(String[ ] args) {
            Scanner input = new Scanner(System.in);
            System.out.print("请输入Java成绩:");
            int java = input.nextInt();
            //……
            /*计算并显示输出*/
            int total = java + c + db;
            double avg = total / 3;
            System.out.print("总成绩:" + total);
            System.out.print("\n平均分: " + avg);
}

ScoreCalc类 和 Test类
image.png

查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程05Java二重循环

配套视频教程

本文B站配套视频教程

循环回顾

某次程序大赛,S1班有4名学员参加,学员的成绩由用户输入,计算该班参赛学员的平均分

二重循环

若有3个班级各4名学员参赛,如何计算每个班级参赛学员的平均分?

image.png

使用二重循环实现--一个循环体内又包含另一个完整的循环结构

外层循环控制班级数目,内层循环控制每个班级学员数目

image.png

        int classNum = 3;
        int studentNum = 4;
        Scanner scanner = new Scanner(System.in);
//        外层循环控制班级数目

        for(int i = 0; i < classNum; i++)
        {
            int total = 0;//某个班级全部学员的总成绩
            for(int j = 0; j < studentNum; j++)
            {
                System.out.println("请输入第"+(i+1)+"个班级"+"第"+(j+1)+"个学员的成绩");
                int score = scanner.nextInt();
                total += score;
            }
            System.out.println("第"+(i+1)+"个班级的平均成绩是" + total/4);
        }

    for(int i = 0; i <classNum; i++){
        sum = 0.0;                         
        System.out.println("请输入第" + (i+1) + "个班级的成绩");
        for(int j = 0; j < score.length; j++){ 
            System.out.print("第" + (j+1) + "个学员的成绩:");
            score[j] = input.nextInt();
            sum = sum + score[j];    
        }
        aver [i] = sum / score.length;            //计算平均分
        System.out.println(“第”+(i+1)+“个班级平均分" + aver [i] + "\n");
    }    

如何用*打印矩形图案?

image.png

分析
用二重循环实现
外层循环控制行数
内层循环控制每行的*号数

   for (int m = 0; m < 5; m++)
        {
            for (int i = 0; i < 5; i++)
            {
                System.out.print("*\t");
            }
            System.out.println("");
        }

打印倒直角三角形

image.png

从控制台输入直角三角形的高度(行数)
每行*的数目从下至上依次为1、2、3、4…

//*****
//****
//***
//**
//*
//        第1行 m=5,里层循环要打印5个*
//        第2行 m=4,里层循环要打印4个*
//        第3行 m=3,里层循环要打印3个*
        //for (int m = 0; m < 5; m++)//控制的是打印多少行
        Scanner scanner  = new Scanner(System.in);
        System.out.println("输入行数");
        int row = scanner.nextInt();
        for (int m = row; m > 0; m--)//控制的是打印多少行
        {
            for (int i = 0; i < m; i++)//控制的是每行打印多少列
            {
                System.out.print("*\t");
            }
            System.out.println("");
        }

打印直角三角形

image.png

从控制台输入直角三角形的高度(行数)
每行 * 的数目依次为1、3、5、7…

分析
实现思路
外层循环控制行数
分析每行打印的内容
每一行打印字符*结束后要换行

内层循环的条件 j<=2i-1

打印九九乘法表

image.png

  for (int m = 0; m < 9; m++)//控制的是打印多少行
        {
            for (int i = 0; i < 1+m; i++)//控制的是每行打印多少列
            {
                System.out.print((i+1)+"*"+(m+1)+"="+((i+1)*(m+1))+"\t");
            }
            System.out.println("");
        }

分析
九九乘法表共有9行,因此外层循环条件为

        i<=9

第i行上有i个式子,因此因此外层循环条件为

       j <= I

第i行上的第j个式子为

         j的值 * i的值 = j*i的值

在二重循环中使用continue

若有3个班级各4名学员参赛,计算每个班级参赛学员平均分,统计成绩大于85分学员数

image.png

查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程04Java数组

配套视频教程

本文B站配套视频教程

image.png

问题

Java考试结束后,老师给张浩分配了一项任务,让他计算全班(30人)的平均分
int stu1 = 95;
int stu2 = 89;
int stu3 = 79;
int stu4 = 64;
int stu5 = 76;
int stu6 = 88;
……
avg = (stu1+stu2+stu3+stu4+stu5…+stu30)/30;

数组

数组是一个变量,存储相同数据类型的一组数据
image.png

声明一个变量就是在内存空间划出一块合适的空间
声明一个数组就是在内存空间划出一串连续的空间

数组基本要素

  • 标识符:数组的名称,用于区分不同的数组
  • 数组元素:向数组中存放的数据
  • 元素下标:对数组元素进行编号,从0开始,数组中的每个元素都可以通过下标来访问
  • 元素类型:数组元素的数据类型

image.png

数组长度固定不变,避免数组越界
数组中的所有元素必须属于相同的数据类型

使用数组步骤:

image.png

  1. 声明数组: 告诉计算机数据类型是什么
int[ ] score1;             //Java考试成绩
int score2[ ];             //oracle考试成绩
String[ ] name;        //学生姓名

image.png

  1. 分配空间: 告诉计算机分配几个连续的空间
score = new int[30]; 
avgAge = new int[6];     
name = new String[30];

声明数组并分配空间
数据类型[ ] 数组名 = new 数据类型[大小] ;
image.png

  1. 赋值:向分配的格子里放数据

score[0] = 89;
score[1] = 79;
score[2] = 76;
……

![image.png](http://upload-images.jianshu.io/upload_images/468490-40a98f27e4e44f00.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

方法1: 边声明边赋值

int[ ] score = {89, 79, 76};
int[ ] score = new int[ ]{89, 79, 76};

方法2:动态地从键盘录入信息并赋值

Scanner input = new Scanner(System.in);
for(int i = 0; i < 30; i ++){

 score[i] = input.nextInt();

}

4. 对数据进行处理:计算5位学生的平均分

int [ ] score = {60, 80, 90, 70, 85};
double avg;
avg = (score[0] + score[1] + score[2] + score[3] + score[4])/5;

访问数组成员:使用“标识符[下标]”

int [ ] score = {60, 80, 90, 70, 85};
int sum = 0;
double avg;
for(int i = 0; i < score.length; i++){

 sum = sum + score[i];

}
avg = sum / score.length;

### 例子
>计算全班学员的平均分

public static void main(String[ ] args) {

    int[ ] scores = new int[5];    //成绩数组
    int sum = 0;            //成绩总和
    Scanner input = new Scanner(System.in);
    System.out.println("请输入5位学员的成绩:");
    for(int i = 0; i < scores.length; i++){
        scores[i] = input.nextInt();
        sum = sum + scores[i];    //成绩累加
    }
    System.out.println("平均分是:" + (double)sum/scores.length);
  }    
### 数组使用常见错误

public class ErrorDemo1 {

 public static void main(String[ ] args){
      int[ ] score = new int[ ];
      score[0] = 89;
      score[1] = 63;
      System.out.println(score[0]);
}

}

public class ErrorDemo2 {

public static void main(String[ ] args) {
    int[ ] scores = new int[2];
    scores[0] = 90;
    scores[1] = 85;
    scores[2] = 65;
    System.out.println(scores[2]);
}

}

public static void main(String[ ] args){

   int[ ] score = new int[5];
   score = {60, 80, 90, 70, 85};
  
   int[ ] score2;
   score2 = {60, 80, 90, 70, 85}; 

}


#### 一个练习

> 有一个数列:8,4,2,1,23,344,12
循环输出数列的值
求数列中所有数值的和
猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数 

// 有一个数列:8,4,2,1,23,344,12
// 循环输出数列的值
// 求数列中所有数值的和

    //        猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数
    int[] array = {8,4,2,1,23,344,12};

    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个数");
    int num = scanner.nextInt();
    int i = 0;
    //拿数组中的每一个元素和num比较,如果想等,输出包含,否则,输出不包含
    for(i = 0; i < array.length; i++)
    {
        if(array[i]==num)
        {
            System.out.println("包含");
            break;
        }
    }

    //说明循环了一圈都没有发现用户输入的值
    if(i==array.length)
    {
        System.out.println("不包含");
    }
### 数组排序

>循环录入5位学员成绩,进行升序排列后输出结果

使用java.util.Arrays类
java.util包提供了许多工具类
Arrays类提供操作数组的方法,例排序、查询
Arrays类的sort()方法: 对数组进行升序排列
 ……
 int[] scores = new int[5];    //成绩数组
Scanner input = new Scanner(System.in);
System.out.println("请输入5位学员的成绩:");
for(int i = 0; i < scores.length; i++){
    scores[i] = input.nextInt();
}

Arrays.sort(scores);            
System.out.print("学员成绩按升序排列:");
for(int i = 0; i < scores.length; i++){
    System.out.print(scores[i] + " ");
}
### 查找数组中的最大值

>从键盘输入本次Java考试五位学生的成绩,求考试成绩最高分

// 从键盘输入本次Java考试五位学生的成绩,求考试成绩最高分

    //将5个成绩保存到数组中,
    //然后,遍历数组,找出数组中最大的数
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入成绩");
    int[] scores = new int[5];
    //将5个成绩保存到数组中,
    for(int i = 0; i < scores.length; i++)
    {
        System.out.println("输入第" + (i + 1) + "次成绩");
        scores[i] = scanner.nextInt();
    }
    //然后,遍历数组,找出数组中最大的数
    int max = scores[0];////让max等于数组中第一个元素
    for(int i = 1; i < scores.length; i++)
    {
        if(max < scores[i])
        {
            max = scores[i];//谁比他大,他就变成谁
        }
    }
    System.out.println("最大值是" + max);

### 数组插入算法
>有一组学员的成绩{99,85,82,63, 60},将它们按升序排列。要增加一个学员的成绩,将它插入成绩序列,并保持升序。

![image.png](http://upload-images.jianshu.io/upload_images/468490-91ddf9a656c28cc8.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

分析:
将成绩序列保存在长度为6的数组中
通过比较找到插入位置
将该位置后的元素后移一个位置
将增加的学员成绩插入到该位置 

// 有一组学员的成绩{99,85,82,63, 60},将它们按升序排列。
// 要增加一个学员的成绩,将它插入成绩序列,并保持升序

    int[] scores = {99,85,82,63, 60};

    Arrays.sort(scores);

    for(int i = 0; i < scores.length; i++)
    {
        System.out.print(scores[i]+" ");
    }


    // 要增加一个学员的成绩,将它插入成绩序列,并保持升序

    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入下一个学生成绩");

    int input = scanner.nextInt();
    int pos = 0;//用户输入的数在新数组中正确的插入位置
    //遍历原始数组,找到要插入的位置
    for(int i = 0; i < scores.length; i++)
    {
        if(input <= scores[i])
        {
            pos = i;
            break;
        }
    }


    //再建一个新的数组,包含6个元素
    int[] scores2 = new int[6];
    //拷贝旧数组从0开始
    // 到pos位置的数到对应新数组同样下标中

    for(int i = 0; i < pos; i++)
    {
        scores2[i] = scores[i];
    }

    scores2[pos] = input;
    //拷贝旧数组从pos+1开始
    // 到旧数组长度位置的数到对应新数组同样下标中
    for(int i = pos+1; i < scores2.length; i++)
    {
        scores2[i] = scores[i-1];
    }

   for(int i = 0;  i<scores2.length; i++)
   {
       System.out.print(scores2[i]+" ");
   }

### 字符逆序输出
将 一组乱序的字符进行排序
进行升序和逆序输出  
![image.png](http://upload-images.jianshu.io/upload_images/468490-3af982fb57629829.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
1.创建数组存储原字符序列。
2.利用Array类的sort( )方法对数组进行排序,并循环输出。
3. 从最后一个元素开始,将数组中的元素逆序输出。
char[] charArray2 = {'a','c','u','b','e','p','f','z'};
    //字符串可以看成是字符数组
    String str = "abcefpuz";

    System.out.println(charArray2.length);
    System.out.println(charArray2);
    Arrays.sort(charArray2);
    System.out.println(charArray2);

    for(int i = charArray2.length - 1; i >= 0; i--)
    {
        System.out.print(charArray2[i]);
    }
在上一个练习的基础上改进:
    向上一个练习中得到的升序字符序列中插入一个新的字符,要求插入之后字符序列仍保持有序
![image.png](http://upload-images.jianshu.io/upload_images/468490-15d0dc92ea4bddd3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

### 字符串数组

>定义一个字符串数组,查找某个字符串在数组中出现的次数

String[] array = {"zhangsan","lisi","wangwu","lisi"};

    String name = "wangwu";
    int count = 0;//count计数,数字num在数组中出现的次数
    for(int i = 0; i < array.length; i++)
    {
        if(array[i].equals(name))
        {
            count++;
        }
    }

    System.out.println(count);
### 作业
1.歌手打分: 
在歌唱比赛中,共有10位评委进行打分,在计算歌手得分时,去掉一个最高分,去掉一个最低分,然后剩余的8位评委的分数进行平均,就是该选手的最终得分。输入每个评委的评分,求某选手的得分。

2.现在有如下一个数组: 
int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; 
要求将以上数组中的0项去掉,将不为0的值存入一个新的数组,生成新的数组为 
查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程03Java循环结构

配套视频教程

本文B站配套视频教程

几个问题

张三oracle考试成绩未达到自己的目标。为了表明自己勤奋学习的决心,他决定写一百遍“好好学习,天天向上!”

循环结构语法

image.png

特点:先判断,再执行

image.png

实现打印50份试卷

分析是否包含重复操作?

使用while循环的步骤

  1. 确定循环条件和循环操作
  2. 套用while语法写出代码
  3. 检查循环是否能够退出

一个练习

老师每天检查张三的学习任务是否合格,如果不合格,则继续进行。
老师给张三安排的每天的学习任务为:上午阅读教材,学习理论部分,下午上机编程,掌握代码部分。
  • 分析是否存在重复操作
  • 使用while循环实现
  1. 确定循环条件和循环操作
  2. 套用while语法写出代码
  3. 检查循环是否能够退出

image.png

提示:判断字符串是否相等使用equals函数
 String input = "no";
        while(input.equals("no"))
        {
            System.out.println("合格了吗?(yes/no):");
            Scanner scanner = new Scanner(System.in);
            //接收用户输入
            input = scanner.next();
            if(input.equals("no"))//说明不合格
            {
                System.out.println("学习学习");
            }
        }
        System.out.println("完成学习任务");

练习二

2012年培养学员10万人,每年增长20%,请问按此增长速度,到哪一年培训学员人数将达到100万人?

提示:循环条件和循环操作分别是什么?
2、2013年培训学员数量 = 100000 * (1 + 0.2 )
3、int year = 2012;

  double students = 100000; 
  while …
public class whileDemo2 {
    public static void main(String[] args) {
//        2012年培养学员10万人,每年增长20%,
// 请问按此增长速度,到哪一年培训学员人数将达到100万人?

        int year = 2012;
        double personCount = 100000;

        while(personCount <= 1000000)
        {
            //增加年数
            year++;
            //增加人数(1.2)
            personCount = personCount*1.2;
            System.out.println(year+"年"+personCount+"人");
        }

        System.out.println(year);
    }

}

程序调试

在编写程序过程中有时也出现错误,但不好发现和定位错误,有没有好的方法呢?
  • 通过代码阅读或者加输出语句查找程序错误
  • 当程序结构越来越复杂时,需要专门的技术来发现和定位错误,就是“程序调试”

image.png

调试例子

顺序输出1~5这5个数字

    int i = 1;
        System.out.println("程序调试演示,注意观察i的值:");
        while(i < 5){
            System.out.println(i);
            i++;
        }

image.png

调试解决问题

调试练习

编程实现:计算100以内(包括100)的偶数之和
设置断点并调试程序,观察每一次循环中变量值的变化
 int i = 1;
       int total = 0;
       while(i <= 100)
       {
            if(i%2==0)//说明是偶数
            {
                total = total + i;
            }
            
            i++;
       }
        System.out.println(total);

另一个问题(do-while循环)

经过几天的学习,老师给张三一道测试题,
让他先上机编写程序完成
然后老师检查是否合格。如果不合格,则继续编写。……

image.png

image.png

特点:先执行,再判断

while循环和do-while循环的区别

  • 执行次序不同
  • 初始情况不满足循环条件时

while循环一次都不会执行
do-while循环不管任何情况都至少执行一次

作业

实现整数反转 用户输入任意一个数字比如12345,程序输出54321
要求用循环实现,并练习调试技巧
  Scanner scanner =  new Scanner(System.in);
        System.out.println("请输入一个数");
        int num = scanner.nextInt();

        //12345模10能到最后一位,输出它,再除以10,1234
        //重复上一步
        while(num>0)
        {
            //12345模10能到最后一位,输出它,再除以10,1234
            System.out.print(num % 10);
            num = num / 10;
        }

问题回顾 输出100次“好好学习!”

image.png

for循环的语法和执行顺序

image.png

问题

循环输入某同学高考考试的5门课成绩,并计算平均分

image.png

分析
循环次数固定
使用for循环结构的步骤
1、分析循环条件和循环操作
2、套用for语法写出代码
3、检查循环是否能够退出

循环条件:循环的次数不足5,继续循环
循环操作:录入成绩,计算成绩之和

public class whileDemo2 {
    public static void main(String[] args) {

        //循环输入某同学高考考试的5门课成绩,并计算平均分
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入学生姓名");
        String name = scanner.next();

        int score = 0;
        int total = 0;
        for(int i = 1; i <= 5; i++)
        {
            System.out.println("请输入"+i+"成绩");
            score = scanner.nextInt();
            total = total + score;
        }

        System.out.println(name+"的平均成绩是"+total/5);
    }

}

输出如图所示加法表

image.png

使用for循环:
1、循环初始化:i = 0;j = 输入值
2、循环条件:i<=输入值
3、循环操作:计算i+j
4、循环变量的改变:i++,j--

public class whileDemo2 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个值");
        int num = scanner.nextInt();//6

        int j = num;
        for(int i = 0; i <= num; i++)
        {

            System.out.println(i+"+"+j+"="+num);
            j--;
        }

    }
}

 练习

求1~100之间不能被3整除的数之和

提示:
1、循环条件:i<100
2、循环操作:if (i % 3 != 0) {

         sum = sum + i;
         }
计算100以内的奇数之和

设置断点调试程序,追踪3个表达式的执行顺序及循环变量的变化

回顾break语句

image.png

break:改变程序控制流

用于do-while、while、for中时,可跳出循环而执行循环后面的语句

练习

循环录入某学生5门课的成绩并计算平均分,如果某分数录入为负,停止录入并提示录入错误

image.png

分析
循环录入成绩,判断录入正确性:录入错误,使用break语句立刻跳出循环;否则,累加求和

public class whileDemo2 {
    public static void main(String[] args) {

        //循环输入某同学高考考试的5门课成绩,并计算平均分
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入学生姓名");
        String name = scanner.next();

        int score = 0;
        int total = 0;
        boolean error = false;//假设用户录入没错误
        for(int i = 1; i <= 5; i++)
        {
            System.out.println("请输入"+i+"成绩");
            score = scanner.nextInt();
            if(score<0 || score>100)
            {
                error = true;//用户录入有误
                break;
            }
            total = total + score;

        }

        if(error == false)
        {
            System.out.println(name+"的平均成绩是"+total/5);
        }
        else
        {
            System.out.println("录入有误");
        }


    }
}
1~10之间的整数相加,得到累加值大于20的当前数

提示
1、使用循环进行累加,从1到10
2、判断累加值是否大于20
3、如果大于20,则跳出循环,并打印当前值

  int total = 0;

        int i = 1;
        for(i=1; i <=10; i++)
        {
            total = total + i;
            if(total > 20)
            {
                break;
            }
           
        }
        System.out.println(i);

continue语句

continue 作用:跳过循环体中剩余的语句而执行下一次循环

循环录入Java课的学生成绩,统计分数大于等于80分的学生比例

image.png

1、通过循环,获得分数大于等于80分的学生人数num
2、判断:如果成绩<80,不执行num++,直接进入下一次循环

  • break语句终止某个循环,程序跳转到循环块外的下一条语句
  • continue跳出本次循环,进入下一次循环
    public static void main(String[] args) {
//       循环录入Java课的学生成绩,
// 统计分数大于等于80分的学生比例

        //5次成绩里,大于等于80分的次数


        int count = 0;
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入班级总人数");
        int personCount = scanner.nextInt();
        for(int i = 1; i <= personCount; i++)
        {
            System.out.println("请输入第" + i + "次成绩");
            //保存本次成绩
            int score = scanner.nextInt();
            //如果成绩小于80的话,跳出本次循环
            //即不累加次数
            if(score < 80)
            {
                continue;
            }

            count++;//累加成绩大于等于80的次数
        }

        System.out.println("80分以上学生人数为" + count);
//        double rate = (double) count/personCount;

    }
}
求1~10之间的所有偶数和

提示
1、使用循环进行累加,循环的范围是从1至10
2 、判断当前数是否为偶数
3 、如果为奇数跳过,执行下一个循环,如果为偶数,进行累加

查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程02java选择结构

配套视频教程

本文B站配套视频教程

image.png

几个问题

如果张浩的Java考试成绩大于98分,张浩就能获得一个MP4作为奖励

image.png

image.png

 public static void main(String[] args) {
        System.out.println("输入张三的java成绩");
        Scanner scanner =  new Scanner(System.in);
        int score = scanner.nextInt();
        if(score > 98)
        {
            System.out.println("--------------");
            System.out.println("奖励一个iphone手机");
        }
        System.out.println(score);
    }
张浩Java成绩大于98分,而且音乐成绩大于80分,老师奖励他;或者Java成绩等于100分,音乐成绩大于70分,老师也可以奖励他

image.png

 public static void main(String[] args) {
        Scanner scanner =  new Scanner(System.in);

        System.out.println("输入张三的java成绩");
        int scoreJava = scanner.nextInt();
        System.out.println("输入张三的音乐成绩");
        int scoreMusic = scanner.nextInt();
        if((scoreJava > 98 && scoreMusic > 80)
                || (scoreJava == 100 && scoreMusic > 70))
        {
            System.out.println("--------------");
            System.out.println("奖励一个iphone手机");
        }
        System.out.println("程序退出");
    }

练习1

输入一个数,如果是偶数,则输出
     Scanner scanner =  new Scanner(System.in);
        System.out.println("输入一个数");
        int num = scanner.nextInt();
        if(num % 2 == 0)
        {
            System.out.println("偶数");
        }
        System.out.println("程序退出");
输入一个数,//如果这个数是偶数,或者能被3整除,则输出这个数
     Scanner scanner =  new Scanner(System.in);
        System.out.println("输入一个数");
        int num = scanner.nextInt();
        if(num % 2 == 0 || num % 3 == 0)
        {
            System.out.println(num);
        }
        System.out.println("程序退出");
如果张浩Java考试成绩大于98分,老师就奖励他一个MP4,否则老师就罚他进行编码
image.png
      Scanner scanner =  new Scanner(System.in);
        System.out.println("输入张三的java成绩");
        int scoreJava = scanner.nextInt();

        if(scoreJava > 98)
        {
            System.out.println("奖励iphone");
        }
        else
        {
            System.out.println("去编码");
        }

        System.out.println("程序退出");
        System.out.println("程序退出");
        System.out.println("程序退出");

小练习

会员号的百位数字等于产生的随机数字即为幸运会员
image.png
image.png

实现思路

  1. 产生随机数
  2. 从控制台接收一个4位会员号
  3. 分解获得百位数
  4. 判断是否是幸运会员

产生随机数(0~9)的方法如下:

    int random=(int)(Math.random()*10);

用户输入2个数,输出这2个数之间的随机的一个数

 Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int low = scanner.nextInt();
        System.out.println("请输入第2个数");
        int high = scanner.nextInt();

        //low----high
        //20------50
        //0-------30(high-low)
        int num = (int)(Math.random()*(high-low))+low;
        System.out.println(num);
public class ForturnMember {
    public static void main(String[] args) {
        //用户输入一个4位的会员号,比如9527
        //如果,会员号的百位数字等于系统产生的随机数字 即为幸运会员
        //否则,输出谢谢惠顾

        //接收用户输入的会员号
        Scanner scanner = new Scanner(System.in);
        int no = scanner.nextInt();//9527
        //提取会员号的百位数字
        //将百位的5变为个位的
        no = no / 100;
        //提取个位上的数,方法就是%10
        no = no % 10;
        //系统产生一个随机数字(0-10),不包括10
        int randomNum = (int)(Math.random()*10);

        System.out.println("随机产生的数字是" + randomNum);

        //比较百位数是否等于随机数
        if(no == randomNum) {
            System.out.println("幸运会员");
        } else {
            System.out.println("谢谢惠顾");
        }

    }
}

另一个问题

对学员的结业考试成绩评测
成绩>=80 :良好
成绩>=60 :中等
成绩<60 :差

多重选择结构

image.png

//        对学员的结业考试成绩评测
//        成绩>=90 :优秀
//        成绩>=80 :良好
//        成绩>=60 :中等
//        成绩<60 :差
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();
        //判断成绩
        //看看是否大于等于90
        if(score >= 90)
        {
            System.out.println("优秀");
        }
        //score<90
        else if(score >= 80)
        {
            System.out.println("良好");
        }
        //score<80
        else if(score >= 60)
        {
            System.out.println("中等");
        }
        else{
            System.out.println("差");
        }

        System.out.println("程序退出");

我想买车,买什么车决定于我在银行有多少存款
如果我的存款超过500万,我就买路虎
否则,如果我的存款超过100万,我就买宝马
否则, 如果我的存款超过50万,我就买迈腾
否则, 如果我的存款超过10万,我就买福特
否则, 如果我的存款10万以下 ,我买比亚迪

嵌套选择结构

学校举行运动会,百米赛跑跑入10秒内的学生有资格进决赛,根据性别分别进入男子组和女子组

分析
判断是否能够进入决赛
在确定进入决赛的情况下,判断是进入男子组,还是进入女子组
image.png

 //学校举行运动会,百米赛跑跑入10秒内的学生有资格进决赛,
        // 根据性别分别进入男子组和女子组

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入百米赛跑成绩");
        //获得运动员的百米成绩
        double second = scanner.nextDouble();
        //判断是否在10秒内
        if(second <= 10)
        {
            // 根据性别分别进入男子组和女子组
            System.out.println("请输入性别");
            String sex = scanner.next();
            if(sex.equals("男"))//sex=="男"
            {
                System.out.println("进入男子组");
            }
            else {
                System.out.println("进入女子组");
            }

        }
        else {
            System.out.println("被淘汰");
        }
        System.out.println("退出程序");

课后作业

1.输入小明的考试成绩,显示所获奖励
成绩==100分,爸爸给他买辆车
成绩>=90分,妈妈给他买MP4
90分>成绩>=60分,妈妈给他买本参考书
成绩<60分,什么都不买

几个问题

张三参加计算机编程大赛
如果获得第一名,将保送清华大学
如果获得第二名,将奖励苹果电脑一部
如果获得第三名,将奖励华为手机一个
否则,不给任何奖励

image.png

在每个case后不要忘记写break;

switch后面小括号中表达式的值必须是整型或字符串

    Scanner scanner = new Scanner(System.in);
        System.out.println("请输入名次");
        int mingci = scanner.nextInt();
        switch (mingci)
        {
            case 1:
            {
                System.out.println("保送清华");
                break;
            }
            case 2:
            {
                System.out.println("送苹果笔记本");
                break;
            }
            case 3:
            {
                System.out.println("送华为手机");
                break;
            }
            default://缺省的,不满足以上情况,进入到default语句
            {
                System.out.println("继续努力");
                break;
            }
        }
        System.out.println("程序结束");

根据用户输入,输出食堂菜谱

 Scanner scanner = new Scanner(System.in);
        System.out.println("请输入星期");
        String week = scanner.next();
        switch (week)
        {
            case "星期一":
            {
                System.out.println("鱼香肉丝");
                break;
            }
            case "星期二":
            {
                System.out.println("唐初排骨");
                break;
            }

            default:
            {
                System.out.println("没有这么一天");
                break;
            }
        }
查看原文

赞 0 收藏 0 评论 0

豆约翰 发布了文章 · 10月1日

Java零基础系列教程01变量,类型,运算符,表达式

配套视频教程

本文B站配套视频教程

image.png

常量

(1)在程序执行的过程中,其值不发生改变的量

(2)字面值常量
    A:字符串常量 "hello"
    B:整数常量    12,23
    C:小数常量    12.345
    D:字符常量    'a','A','0'
    E:布尔常量    true,false
    F:空常量    null(后面讲)
/*
    常量:
        在程序执行过程中,其值不发生改变的量。
        
    分类:
        A:字面值常量
        B:自定义常量(后面讲)
        
    字面值常量
        A:字符串常量    用双引号括起来的内容。
            举例:"hello","world","HelloWorld"
        B:整数常量    所有的整数
            举例:100,200
        C:小数常量    所有的小数
            举例:10.23,110.11
        D:字符常量    用单引号括起来的内容
            举例:'a','A','0'
            错误的:'ab'
        E:布尔常量    比较特殊
            举例:true,false
        F:空常量    后面讲
            举例:null
*/
class ConstantDemo {
    public static void main(String[] args) {
        //字符串常量的输出
        System.out.println("hello");
        
        //整数常量的输出
        System.out.println(100);
        
        //小数常量的输出
        System.out.println(100.10);
        
        //字符常量的输出
        System.out.println('a');
        System.out.println('A');
        System.out.println('0');
        //这个是有问题的,字符常量有单引号,字符串常量用双引号
        //System.out.println('ab');
        
        //布尔常量的输出
        System.out.println(true);
        System.out.println(false);
    }
}

变量的三要素

类型,变量名,保存的值

基本数据类型

  1. 数值
  • 整数 byte,short,int,long
    25,-987, 0
  • 小数 float,double
    5.23,3.14
  1. 字符串
  • 字符串 String

"你好","中国的首都"

  • 字符 char

'a', '的'

  1. 布尔型

boolean

使用一个变量的步骤

  1. 定义一个变量

数据类型 变量名;
int money;

2.给变量赋值
变量名 = 数值;
money = 1000 ;

第一步和第二步可以合并
数据类型 变量名=数值;
int money = 1000;

3.使用这个变量
System.out.println(money );

    int age;//定义一个变量
    age = 34; //给变量赋值
    System.out.println(age); //在屏幕上输出变量的值
    
    String name="zhangsan";//定义一个变量,并且马上给其赋值
    System.out.println(name); //在屏幕上输出变量的值

定义几个变量

手机的品牌brand是华为,价格(price)2500,重量(weight)0.125千克,
颜色(color) 红

String brand = "华为";
int price = 2500;
double weight = 0.125;
char color = '红';

   System.out.println("手机品牌:" + brand);
  System.out.println("手机价格:" + price);

image.png

获取用户输入

使用Scanner类

Scanner sc = new Scanner(System.in);


/*
 * Scanner:用于接收键盘录入数据。
 * 
 * 前面的时候:
 *         A:导包
 *         B:创建对象
 *         C:调用方法
 * 
 */
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);

        int x = sc.nextInt();
        
        System.out.println("x:" + x);
    }
}
        Scanner scanner = new Scanner(System.in);//定义一个从屏幕获得输入信息的变量scanner

        System.out.println("请输入您的年龄");
        int age = scanner.nextInt();//获得用户从屏幕输入的一个整数,有一个阻塞的副作用,通俗点说,就是程序卡在这里了

        System.out.println("您的年龄是" + age);
        System.out.println("请输入您的姓名");
        String name = scanner.next();//获得用户从屏幕输入的一个字符串,有一个阻塞的副作用,通俗点说,就是程序卡在这里了

        System.out.println("欢迎您" + name);

Scanner类的hasNextInt()和nextInt()方法


import java.util.Scanner;

/*
 * 基本格式:
 *         public boolean hasNextXxx():判断是否是某种类型的元素
 *         public Xxx nextXxx():获取该元素
 * 
 * 举例:用int类型的方法举例
 *         public boolean hasNextInt()
 *         public int nextInt()
 * 
 * 注意:
 *         InputMismatchException:输入的和你想要的不匹配
 */
public class ScannerDemo {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);

        // 获取数据
        if (sc.hasNextInt()) {
            int x = sc.nextInt();
            System.out.println("x:" + x);
        } else {
            System.out.println("你输入的数据有误");
        }
    }
}

Scanner类中的nextLine()产生的换行符问题

import java.util.Scanner;

/*
 * 常用的两个方法:
 *         public int nextInt():获取一个int类型的值
 *         public String nextLine():获取一个String类型的值
 * 
 * 出现问题了:
 *         先获取一个数值,在获取一个字符串,会出现问题。

 * 如何解决呢?
 *         A:先获取一个数值后,在创建一个新的键盘录入对象获取字符串。
 *         B:把所有的数据都先按照字符串获取,然后要什么,你就对应的转换为什么。
 */
public class ScannerDemo {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);

        // 获取两个int类型的值
        // int a = sc.nextInt();
        // int b = sc.nextInt();
        // System.out.println("a:" + a + ",b:" + b);
        // System.out.println("-------------------");

        // 获取两个String类型的值
        // String s1 = sc.nextLine();
        // String s2 = sc.nextLine();
        // System.out.println("s1:" + s1 + ",s2:" + s2);
        // System.out.println("-------------------");

        // 先获取一个字符串,在获取一个int值
        // String s1 = sc.nextLine();
        // int b = sc.nextInt();
        // System.out.println("s1:" + s1 + ",b:" + b);
        // System.out.println("-------------------");

        // 先获取一个int值,在获取一个字符串,这里会出问题
        // int a = sc.nextInt();
        // String s2 = sc.nextLine();
        // System.out.println("a:" + a + ",s2:" + s2);
        // System.out.println("-------------------");

        int a = sc.nextInt();
        Scanner sc2 = new Scanner(System.in);
        String s = sc2.nextLine();
        System.out.println("a:" + a + ",s:" + s);
    }
}

运算符

  1. 赋值运算符
    =
员王浩的Java成绩是80分,学员张萌的Java成绩与王浩的相同,输出张萌的成绩
int wangScore = 80;    //王浩成绩
int zhangScore;        //张萌成绩
zhangScore = wangScore; 
System.out.println(“张萌成绩是" +zhangScore);

2.算数运算符
+,-,*,/,%

        System.out.println(1600%5);//0-4
        System.out.println(3%5);//3
        System.out.println(3%2);//1
        System.out.println(21%5);//1
        System.out.println(13%4);//1
//        System.out.println(m%n);//0----n-1
        System.out.println(23%7);//2
        System.out.println(25%7);//4

一个问题

用户在屏幕上输入一个天数,程序回答出是几周零几天?

   //  用户在屏幕上输入一个天数,程序回答出是几周零几天?
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入天数");
        //获得用户输入的天数dayCount
        int dayCount = scanner.nextInt();
        System.out.println(dayCount+"天是"+ dayCount/7 + "周零" +  dayCount%7 + "天");

关系运算符

比较高低、大小、长短等
张三的考试成绩是否比李四高
大象是否比乌龟更长寿
篮球跟地球一样大吗

,<
==,!=
=,<=
boolean (布尔)类型
boolean类型的值:
真:true
假:false

表达式(3+40%6)>(9/2*3)的结果是什么?

false

从控制台输入张三同学的成绩,与李四的成绩(80分)比较,输出“张三的成绩比李四的成绩高吗?” 的判断结果

image.png

int liSi = 80;          //学员李四成绩
boolean isBig ;    
        
Scanner input = new Scanner(System.in);   
System.out.print("输入学员张三成绩: ");       
int zhangSan =  input.nextInt();                     //输入张三的成绩 
        
isBig = zhangSan > liSi ; 
System.out.println( "张三成绩比李四高吗 ? "+isBig );    //输出比较结果

表达式

y = x-9+(x +90);

练习

商场推出幸运抽奖活动
抽奖规则:
顾客的四位会员卡号的
各位数字之和大于20,
则为幸运顾客。

image.png

类型转换

自动类型转换

某班第一次Java考试平均分81.29,第二次比第一次多2分,计算第二次考试平均分?
double firstAvg = 81.29;  //第一次平均分
  double secondAvg;         //第二次平均分
  int rise = 2;

  secondAvg = firstAvg + rise;
        
  System.out.println("第二次平均分是:"  + secondAvg);

规则1:如果一个操作数为double型,则整个表达式可提升为double型

规则2:满足自动类型转换的条件
两种类型要兼容:
数值类型(整型和浮点型)互相兼容
目标类型大于源类型:
例如:double 型大于 int 型

强制类型转换

(类型名)表达式

int  b  = (int)10.2;
double a = 10;
int c = (int)a;
去年Apple笔记本所占市场份额是20,今年增长的市场份额是9.8,求今年所占份额?
int before = 20;     //apple笔记本市场份额
double rise = 9.8;     //增长的份额

int now = before+ (int)rise;      //现在的份额
当强制转换时,精度有损失
查看原文

赞 0 收藏 0 评论 0

认证与成就

  • 获得 7 次点赞
  • 获得 4 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 4 枚铜徽章

擅长技能
编辑

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2016-12-09
个人主页被 430 人浏览