java基础1.1

1、接上回：分支结构

1.1 、if..else if..else..多路结构

特点：必走其中支路的语句块之一

结构：

    import java.util.Scanner;
     //成绩等级判断
     public class ScoreLevel {
         public static void main(String[] args) {
             Scanner scan = new Scanner(System.in);
             System.out.println("请输入成绩:");
             double score = scan.nextDouble();
             //带数(888,-56,95,85,65,45)
             if(score<0 || score>100){
                 System.out.println("成绩不合法");
             }else if(score>=90){ //合法
                 System.out.println("A-优秀");
             }else if(score>=80){
                 System.out.println("B-良好");
             }else if(score>=60){
                 System.out.println("C-中等");
             }else{
                 System.out.println("D-不及格");
             }
     
         }
     }

1.2、switch..case 多路结构

特点：

        优点：效率高、结构清晰

        缺点：只能对整数判断相等、不够灵活

注意点：

若有一个case分路为true，除了本身支路，剩下的支路会继续执行直到default语句块执行完，也就是贯穿了剩下支路；如果想要只执行一条支路，需在语句块后面加上break;

语法：

     import java.util.Scanner;
     //命令解析程序
     public class CommandBySwitch {
         public static void main(String[] args) {
             Scanner scan = new Scanner(System.in);
             System.out.println("请选择功能: 1.取款 2.存款 3.查询余额 4.退卡");
             int command = scan.nextInt();
     
             switch(command){
                 case 1:
                     System.out.println("取款业务...");
                     break;
                 case 2:
                     System.out.println("存款业务...");
                     break;
                 case 3:
                     System.out.println("查询余额业务...");
                     break;
                 case 4:
                     System.out.println("退卡业务...");
                     break;
                 default:
                     System.out.println("输入错误");
             }
         }
     }

1.3、支路结构小结、补充：

 1、- if结构：1条路
   - if...else结构：2条路

   - if...else if结构：多条路

   -2、 switch...case结构：多条路

     优点：效率高、结构清晰

     缺点：只能对整数判断相等

     break：跳出switch

     > 若业务是对整数判断相等，首选switch...case

2、循环结构

2.1、循环三要素

        1、循环变量的初始化

        2、循环的条件（以循环变量为基础）

        3、循环变量的改变（以循环结束为导向）

2.2、while循环

特点：重复判断循环条件是否为true，是true则执行循环语句块，否则结束循环；

结构：

import java.util.Scanner;
     //猜数字游戏
     public class Gueesing {
         public static void main(String[] args) {
             Scanner scan = new Scanner(System.in);
             int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
             System.out.println(num); //作弊
     
             //300(大),200(小),250(对)
             System.out.println("猜吧!");
             int guess = scan.nextInt(); //1.
             while(guess!=num){ //2.
                 if(guess>num){
                     System.out.println("太大了");
                 }else{
                     System.out.println("太小了");
                 }
                 System.out.println("猜吧!");
                 guess = scan.nextInt(); //3.
             }
             System.out.println("恭喜你猜对了!");
         }
     }

2.3、do..while（）循环

特点：循环初始化与循环条件改变的编码相同；一定执行一次循环语句块，然后重复判断循环条件，是true则执行循环语句块，是false则结束循环；

结构：

     import java.util.Scanner;
     //猜数字游戏
     public class Gueesing {
         public static void main(String[] args) {
             Scanner scan = new Scanner(System.in);
             int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
             System.out.println(num); //作弊
     
             //假设num=250
             //300(大),200(小),250(对)
             int guess;
             do{
                 System.out.println("猜吧!");
                 guess = scan.nextInt(); //1+3
                 if(guess>num){
                     System.out.println("太大了");
                 }else if(guess<num){
                     System.out.println("太小了");
                 }else{
                     System.out.println("恭喜你猜对了");
                 }
             }while(guess!=num); //2
         }
     }

2.4、for循环

特点：应用率最高的一种循环，它的循环条件与循环次数有直接联系；

结构：

     import java.util.Scanner;
     //随机加法运算器
     public class Addition {
         public static void main(String[] args) {
             Scanner scan = new Scanner(System.in);
             int score = 0; //总分
             for(int i=1;i<=10;i++){ //10次    (1)25+6=?
                 int a = (int)(Math.random()*100); //加数a(0到99之间)
                 int b = (int)(Math.random()*100); //加数b(0到99之间)
                 int result = a+b; //存正确答案
                 System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
                 System.out.println("算吧!");
                 int answer = scan.nextInt(); //2)答题
                 if(answer==-1){ //3)判题
                     break;
                 }
                 if(answer==result){
                     System.out.println("答对了");
                     score += 10; //答对1题，加10分
                 }else{
                     System.out.println("答错了");
                 }
             }
             System.out.println("总分为:"+score);
         }
     }

2.5、三种循环结构的选择

先看循环是否与次数相关：
     - 若相关-----------------------------直接上for
     - 若无关，再看要素1与要素3的代码是否相同：
               - 若相同-----------------------直接上do...while
               - 若不同-----------------------直接上while

2.6、循环补充说明

1、break：跳出循环-------------可以用在switch和循环中

      continue：跳过循环体中剩余语句而进入下一次循环-----------只能用在循环中

2、嵌套循环：

  - 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
  - 执行规则：外层循环走一次，内层循环走所有次
  - 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
  - break只能跳出当前层循环

输出九行九列的星星

    for(int num=1;num<=9;num++){ //控制行
         for(int i=1;i<=num;i++){ //控制列
           System.out.print(i+"*"+num+"="+i*num+"\t"); //print():输出不换行
         }
         System.out.println(); //换行
     }

\t：水平制表位，固定占8位----------一般用于做对齐

3、随机生成语法

 int num = (int)(Math.random()*1000+1); //1到1000之内的随机数

   Math.random()---------------0.0到0.9999999999999999...
   *1000-----------------------0.0到999.99999999999999...
   +1--------------------------1.0到1000.9999999999999...
   (int)-----------------------1到1000

3、数组

3.1、数组基础

1、定义：数组是一种数据类型，为引用类型。他是相同数据类型的元素的集合

2、初始化

     int[] arr = new int[3]; //0,0,0
     int[] arr = {1,4,7}; //1,4,7
     int[] arr = new int[]{1,4,7}; //1,4,7
     int[] arr;
     //arr = {1,4,7}; //编译错误，此方式只能声明同时初始化
     arr = new int[]{1,4,7}; //正确

 3、访问

int[] arr = new int[3];
System.out.println(arr.length); //3

 通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组的长度-1)

       int[] arr = new int[3];
       System.out.println(arr[0]); //0，输出第1个元素的值
       arr[0] = 100; //给arr中的第1个元素赋值为100
       arr[1] = 200; //给arr中的第2个元素赋值为200
       arr[2] = 300; //给arr中的第3个元素赋值为300
       //arr[3] = 400; //运行时会发生数组下标越界异常
       System.out.println(arr[arr.length-1]); //输出最后一个元素的值

4、遍历（迭代）、输出打印

     int[] arr = new int[10];
     for(int i=0;i<arr.length;i++){ //遍历arr数组
         arr[i] = (int)(Math.random()*100); //给每一个元素赋值为0到99的随机数
         System.out.println(arr[i]); //输出每个元素的值
     }

ArrayIndexOutOfBoundsException：数组下标越界异常(下标为0到(数组长度-1)，超出范围则异常)

3.2、数组的复制、扩容、由小到大排序

复制

System.arraycopy(a,1,b,0,4);       
int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0
       
//a:源数组
       
//1:源数组的起始下标
       
//b:目标数组
       
//0:目标数组的起始下标
      
//4:要复制的元素个数
     
System.arraycopy(a,1,b,0,4); //灵活性好
      
 for(int i=0;i<b.length;i++){    
     System.out.println(b[i]);
 }

扩容

int[] b = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1); 

注意：无论是复制还是扩容，都是新建一个数组类型，再把标识符地址重新赋值给新数组，原来的数组不用的话会进入垃圾回收；

排序

     - Arrays.sort(arr);

       ```java
       int[] arr = new int[10];
       for(int i=0;i<arr.length;i++){
           arr[i] = (int)(Math.random()*100);
           System.out.println(arr[i]);
       }
       Arrays.sort(arr); //对arr进行升序排列
       System.out.println("排序后:");
       for(int i=0;i<arr.length;i++){
           System.out.println(arr[i]);
       }
       System.out.println("倒序输出"); //只是倒着显示，但数组中数据没有改变
       for(int i=arr.length-1;i>=0;i--){
           System.out.println(arr[i]);
       }

4、方法（函数、过程）

   - 作用：封装一段特定的业务逻辑功能
   - 方法应尽可能独立，一个方法只干一件事
   - 方法可以被反复多次调用
   - 减少代码重复，有利于代码维护
   - 何时用：假设有一个功能，在很多地方都得使用，就将功能封装到一个方法中

1、方法的五要素

       修饰词 ：暂时先记为public static

       返回值 ：

                有返回值：对应的数据类型（int、double、int[] 、String..）

                无返回值：void

        方法名：小驼峰、英文的见名知义

        参数列表 ：传入方法体里的参数

                  形参：形式参数----定义方法时的参数叫做形参

                  实参：实际参数----调用方法时的参数叫做实参

        方法体：逻辑功能，有返回值的话，需要用return语句；

                        return：

                                功能1：结束方法，return后面语句不再执行；

                                功能2：返回值

结构

  ​	   修饰词   返回值类型   方法名(参数列表) {

   ​         方法体

   ​    }

2、方法体

   //无参无返回值
   public static void say(){
       System.out.println("大家好，我叫WKJ，今年38岁了");
   }
   
   //有参无返回值
   public static void sayHi(String name){ //形参
       System.out.println("大家好，我叫"+name+"，今年38岁了");
   }
   
   //有参无返回值
   public static void sayHello(String name,int age){ //形参
       System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
   }
   
   //无参有返回值
   public static double getNum(){
       //有返回值的方法中，必须有return
       //并且return后数据的类型还必须与返回值类型匹配
       //return "abc"; //编译错误，返回值类型不匹配
       return 8.88; //1)结束方法的执行  2)返回结果给调用方
   }
   
   //有参有返回值
   public static int plus(int num1,int num2){
       int num = num1+num2;
       return num; //返回的是num里面的那个数
       //return num1+num2; //返回的是num1与num2的和
   }
   
   //无参有返回值
   public static int[] testArray(){
       int[] arr = new int[10];
       for(int i=0;i<arr.length;i++){
           arr[i] = (int)(Math.random()*100);
       }
       return arr;
   }

3、方法的调用

        1、无返回值

public class MethodDemo {
    public static void main(String[] args) {
        say(); //调用say()方法
     
        //sayHi(); //编译错误，有参则必须传参
        //sayHi(250); //编译错误，参数类型必须匹配
        sayHi("zhangsan"); //String name="zhangsan"  //实参
        sayHi("lisi"); //String name="lisi"          //实参
        sayHi("wangwu"); //String name="wangwu"      //实参
     
        sayHello("zhangsan",25); //实参 String name="zhangsan",int age=25
        sayHello("lisi",24); //实参
    }
}

        2、有返回值

public class MethodDemo {
    public static void main(String[] args) {
        double a = getNum(); //getNum()的值就是return后的那个数
        System.out.println(a); //8.88，模拟对返回值的后续操作
     
        int b = plus(5,6); //plus(5,6)的值就是return后的那个数
        System.out.println(b); //11，模拟对返回值的后续操作
     
        int m=5,n=6;
        int c = plus(m,n); //传递的是m和n里面的数
        System.out.println(c); //11，模拟对返回值的后续操作
     
        int[] d = testArray();
        System.out.println(d.length); //10，模拟对返回值的后续操作
    }
}

3、方法的重载

方法的签名：方法名+参数列表

规定：在Java中，同一个类里不允许有两个以上相同签名的方法

方法的重载：方法名相同，参数列表不同，这样的方法我们称构成了重载；编译器自动根据方法的签名选择调用的方法；注意返回值不同或者参数名不同与重载无关；

public class OverloadDemo {
    public static void main(String[] args) {
        Aoo o = new Aoo();
         o.show();
        o.show(25);
        o.show("zhangsan");
        o.show("zhangsan",25);
        o.show(25,"zhangsan");
        }
}
class Aoo{
    void show(){}
    void show(String name){}
    void show(int age){}
    void show(String name,int age){}
    void show(int age,String name){}
//int show(){ return 1; } //编译错误，重载与返回值类型无关
//void show(String address){} //编译错误，重载与参数名称无关
}

4、构造方法

作用：用于构造类的新对象，可以传参，给对象属性赋值，与类同名，但没有返回值类型；它与普通方法一样，可以重载；类在新建对象时，会自动构造一个无参的构造方法，如果我们加入了一个有参的构造方法，系统就不会自动加入无参的构造方法；官方建议：类里永远都保持一个无参的构造方法。

public class ConDemo {
    public static void main(String[] args) {
        SayHi demo1 = new SayHi("张三");
        SayHi demo2 = new SayHi("李四","广东",18);
        demo1.say();
        demo2.say();
    }
}

class SayHi{
    String name;
    String address;
    int age;

    SayHi(){

    }
    SayHi(String name){
        this.name = name;
    }
    SayHi(String name,String address,int age){
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public void say(){
        System.out.println("name:"+name+",address:"+address+",age:"+age);
    }

}

5、this的用法

在普通方法里，每一个变量都有一个隐式的this参数，它指向了当前的对象；由于静态区里没有指向任何实例，this不能存在静态区里；

this最常见的用法：

一般来说this都可以省去，但这两种情况下（特别是第一种），需要用到this：

1、构造方法给成员变量属性赋值：

由于构造方法传入的形式参数的取名，一般都与成员变量相同，且两者遵守“就近原则”。因此要想区分两者，需在成员变量前加this；

2、构造方法里调用重载的构造方法（较少用）：

注意this（）；要写在构造方法体里的第一行；

public class ConDemo {
    public static void main(String[] args) {
        SayHi demo1 = new SayHi("张三");
        SayHi demo2 = new SayHi("李四","广东",18);
        demo1.say();
        demo2.say();
    }
}

class SayHi{
    String name;
    String address;
    int age;

    SayHi(){

    }
    SayHi(String name){
        this("王五","北京",38);
        this.name = name;
    }
    SayHi(String name,String address,int age){
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public void say(){
        System.out.println("name:"+name+",address:"+address+",age:"+age);
    }

}