java 10.1/10.2/10.3 总结

java 三大流程控制

1. 顺序控制
依次执行我们的代码。

2. 条件控制
a. 目的 ： 对程序执行，一些不可预知的流程，进行一个预先判断.
b. 条件:条件具有真假的特性。而且只可能为真，或者为假。
c. java条件控制有四种手段:

(1)if语句
结构:

     if(条件){
            //实现我们的逻辑
                }

(2)if...else语句
结构:

       if(条件){
          //实现我们的逻辑
       }else{
            //实现我们的逻辑
                    }

else后面之间跟我们的{//代码}

(3)if(条件)...else if(条件)...(接N个)...else

注意: a.else if(条件): 条件的约束，和我们前面说的if(条件)，俩者是等价的.
         b.else if 可以有多个
         c.else 可以省略掉的, 但是即使没有匹配所有条件，我们依然建议必须有else，来保证 语句的完整和可读性.
         d.如果满足条件只需要执行一行代码，{}也是可以省略的，但是不建议这么做.
  
(4)switch case

结构:

switch(判断值){
   case 值1:
   break;
   case 值2:
   break;
   .......
   case 值n:
   break;
 
   default:
}

条件控制语句来说：
彼此可以嵌套使用的.

3. 表达式的类型:

eg: int a = 5;
      a*3 (结果15)
      表达式的输出类型为表达式计算结果的类型.

------------------

    double num = 1.5;
    num * 4 (6.0, 表达式最终被当做的类型就是double类型)

首先for循环有三个部分组成:
 
 a. 循环变量初始化
 b. 循环条件判断
 c. 循环变量的改变
 
 这三个部分都可以省略，但是; 不可以省略 ????????????

 
 循环变量: 我们可以定义多个,对于循环变量的改变，我们也可以同时改变多组变量
 
 执行流程:
 a.循环变量初始化，这个在整个的循环过程中，只会执行一次
 b.进行循环条件的判断，如果满足条件，则执行，否则结束循环
 c.当循环条件满足之后，并且执行了我们循环中定义的代码，最后就会进行循环变量的改变。

练习1:      定义一个变量，保存年龄。 并且当年龄大于60岁，我们输出老年. 当年龄在 40 到 60 之间，我们输出中年. 当年龄在18 - 40之间，我们输出少年. 如果小于18岁，输出未成年.

  public class Age{
  public  static void main(String [] args){
  int age = 21;
  if (age>60){
  System.out.println("老年");
  }
  else if (age<60&&age>=40){
  System.out.println("中年");
  }
  else if (age<40&&age>=18){
  System.out.println("少年");
  }
  else if (age<18){
  System.out.println("未成年");
  }
}
}

4.循环控制  

a. while 循环

结构:
while(循环条件){
//循环实现的代码
}

b. do .. while循环
结构:

do{
//实现的代码
}while(循环的条件);

c. for 循环
使用率最高的;

结构:

for(循环变量初始化 ;循环条件判断; 循环变量的改变){
 //循环需要实现的逻辑
}

d. foreach 循环(不是一个常规的java提供的循环的方式，他只是java提供的一种语法糖)   语法糖： 针对基本的语法，提供了一种简化的实现方式.
foreach: 对一种循环方式的命名，常规循环的简化方式. 
        

俩个关键字: 应用到循环控制中，continue的含义是跳出当次的循环，break的含义是跳出整个循环

continue:
在循环的代码体中，如果遇到continue, 则会跳出当次循环，循环体内continue之后的代码都不会执行，并且循环变量进行一次改变操作，
之后再次进行条件判断，如果满足条件，则进入循环，否则直接结束循环; 跳出的仅是continue外层直接包裹的循环.

break:
在循环的代码体中，如果遇到break,则会跳出本循环代码块，break后的代码不会执行。并且整个循环的过程结束。
break后退出的循环也是直接包围break的循环。

练习2           求1-50(俩边都闭区间), 所有偶数的和最终输出结果.

  public class ClassTestDemo2{
 
 public static void main(String[] args){
   int minNum = 1;
   final int MAX_NUM = 50;
   int sum = 0;
   while(minNum<=MAX_NUM){
    sum += (minNum%2==0)?minNum:0;
    minNum++;
   }
    System.out.println(sum);
 }
 
}

练习3：    求1-100自然数，其中所有偶数的和，所有奇数的和，并且求所有偶数的和与所有奇数的和的差.

   public class ClassTestDemo3{
 
 public static void main(String[] args){
   int evenSum = 0;
   int unevenSum = 0;
 
   final int MAX_NUM = 100;
   for(int i = 1;i<=MAX_NUM;i++){
    if(i%2==0){
     evenSum+=i;
    }else{
     unevenSum+=i;
    }
   }
   System.out.println(evenSum - unevenSum);
 }
  }

4.数组

阶段性关键字总结:

public,class,static,void,int,boolean,char,byte,long,short,double,float,final.

new:用来创建一个对象。

定义:

数组保存元素的类型 [] 数组变量的名称 = new 数组保存元素的类型[元素的数量];

数组元素的访问: index(数组保存元素的索引) , 从0开始(length-1)

数组来说，如果初始化一个数组，但是并没有保存任何的值，那么数组中会存放一些默认的值:
byte,short,int,long: 0
float，double:0.0
boolean: false
char: ''

数组对象中有一个变量length,能够让我们拿到数组的长度.

一. 数组

1.数组定义: 用来一次性保存多个相同类型元素的这样一种数据结构.

2.维度上分:

一维数组，多维数组.

一维数组:

3.声明:
类型 [] 数组变量名称
int [] arr;
或者
int arr[];
俩种形式都可以，而且没有任何的区别，不过建议我们采取第一种方式.

4.初始化:

动态初始化:
我们在定义一个数组和对数组进行赋值的操作，我们分开来执行。

静态初始化:
我们在定义一个数组的同时，进行数组的初始化

   //动态初始化
   int [] arr = new int[3];
   
   arr[0] = 1;
   arr[1] = 2;
   arr[2] = 3;
   
   //静态初始化
   int []arr1 = new int[]{1,2,3};
   int []arr2 = {1,2,3,4};
   
new:用来初始化一个对象。            注意事项:a. 数组长度一旦指定，是永远不可以改变的。b. 数组保存的元素类型一旦指定，也是不可以改变，并且只能保存该类型的元素

5. length:
  int a[] = new in[3];
  int size = a.length;

6.数组元素的访问
arr[index]: index表示数组元素的索引，注意索引是从0到length-1.
arr[1]:访问第二个元素

index: 可以是常量，也可以是表达式。

课堂练习:
第一个一个保存10个整形元素的一维数组，其中值为1到10,我们分别求 这十个数的和，以及十个数的平均值，
以及俩俩相邻的差，最终的和。

  public class ArrayDemo1{
  public static void main(String[] args){
   //静态初始化
   int [] arr = {1,2,3,4,5,6,7,8,9,10};
    int sum = 0;
   int sumAll = 0;
   double average = 0.0;
   
   for(int i=0;i<arr.length-1;i++){
        sumAll += arr[i];
     sum+=(arr[i]-arr[i+1]);
   }
   
   sumAll += arr[arr.length-1];
   average = 1.0*sumAll/arr.length;
   
   System.out.println(average);
   System.out.println(sum);
   System.out.println(sumAll);
 }
 
}

二维数组:

声明: 类型 [][] 数组名称;
int [][] arr;

初始化:
a.动态初始化
int [][]arr = new int[3][];

b.静态初始化
int [][]arr = {{1,2,3},{2,3,4,5}};

length:
这个属性拿到二维数组的长度。

二. 方法

定义: 实现一个功能的代码片段的封装。

[修饰符...] 返回值类型 方法名称(形参的列表){
 //方法中实现的逻辑
}

形参列表: 方法接收外部传入的数据的接收媒介.
返回值: 方法执行结束之后，返回的值的类型。
如果方法不需要返回任何的值，那么我们的方法返回类型写作void.
在方法里返回一个值，需要用到 return.

形参列表:    当我们定义了一个方法之后，去调用方法的时候，一定要注意我们传递给方法的入参的类型和数量，一定要一一对应。

唯一确定一个方法:
关注点:
a.方法名是否一致
b.形参列表的所有参数类型和数量是否一致。 对于形参变量的命名，完全是没有关系的.
c.返回值的类型
  可以是基本类型，也可以是引用类型。
 
注意:

a.一旦明确指定了方法的返回类型(非void),那么一定要保证最终方法可以成功的返回我们对应的返回类型的数据.
b.关于void返回类型
如果我们不主动的添加return语句，在执行的时候，也会帮我们自动添加return.我们在实现void类型的方法的时候，主动添加一个
return也是没有问题。

java预编译的特点.

方法参数的传递: 方法参数的传递来说，基本类型传递的是值。对于引用类型，传递的是引用.(传递的是地址)

一. 关于变量的作用域:

成员变量:
类的属性

局部变量:
方法中定义的变量或者是方法的形式参数。

对于java语言来说，作用域控制是通过块来控制的.
块的概念: 一对{} 包裹，该代码片段就称为 一块.

对于某个块内定义的变量：
a.对于当前的块，不能再定义同名的变量,即使类型不同也不行。
b.对于当前的块，定义了某个变量，在块外不能够访问到块中定义的变量

如果存在块的嵌套:
那么外层块定义的变量，在内层块中是可以访问到的.

练习:

定义一个类，类中有2个成员变量，再分别定义俩个方法，这俩个方法的作用是给成员变量赋值.

  public class ClassDemo{
    int a;
    int b;
 ClassDemo(int parmA,int parmB){
    a = parmA;
    b = parmB;
  System.out.println("constructor");
 }
 
 ClassDemo(){
  System.out.println("default constructor");
 }
 void setA(int parmA){
  a = parmA;
 }
 void setB(int parmB){
  b = parmB;
 }
 int getAPlusB(){
  return a+b;
 }
 public static void main(String[] args){
  ClassDemo demo1 = new ClassDemo();
  ClassDemo demo2 = new ClassDemo(10,20);
  System.out.println(demo1.getAPlusB());
  System.out.println(demo2.getAPlusB());
  }
 }

二. 构造方法(构造器)

1.类中特殊的方法，对于定义来讲，它的方法名必须和类名一模一样，并且不返回任何的值，主要不能添加void.
2.在new（创建一个对象的时候），一定会去调用它的构造方法。 但是如果我们没有自己添加自己定义的构造器的话，编译器会帮我们
  偷偷的添加一个默认的构造器:
  类名(){
  }
  如果我们主动添加一个默认的构造器，那么在创建对象的时候，通过new 类名(); 会调用我们自己添加的默认构造器.
 
3.当我们主动添加了一个包含参数列表的构造器，并且没有主动添加默认的构造器，则再通过new 类名(); 就会遇到编译问题.

三. 方法重载 overload
 
1. 对于同名的方法，具有不相同的参数列表，我们在访问的时候，通过调用方法传入不同的参数列表，就可以找到我们特定的方法。

2. 当我们定义多个重载的方法的时候，在编译阶段的话，编译器可以根据我们方法形式参数数量以及类型来区别不同的方法，执行阶段可以
   根据我们调用的时候传入的参数列表， 仅仅拥有不同的返回值类型，是不被视为重载的。
  
   练习:
  
   定义一个类，类中有个1维数组的成员变量(short)。 提供俩个方法，第一个方法接受一个int数组，第二个方法接受一个long型的数组。
   俩个方法均将各自 形参传入的数组中元素的值进行求和。 并且与本身我们类成员变量数组的和做一个差。 最终返回这样的结果。
   public class ClassTest2{
 
 short[] arrShort;
 int sum;
 void ClassTest2(){
  System.out.println("ClassTest2 execute !");
 }
 ClassTest2(int a){
  arrShort = new short[]{2,3,4};
  for(int i=0;i<arrShort.length;i++){
   sum+=arrShort[i];
  }
 }
 int getArrPlusResult(int[] arr){
  int sumAll = 0;
  for(int i=0;i<arr.length;i++){
   sumAll+=arr[i];
  }
   return sumAll - sum;
 }
 long getArrPlusResult(long[] arr){
  long sumAll = 0;
  for(int i=0;i<arr.length;i++){
   sumAll+=arr[i];
  }
  return sumAll - sum;
 }
 public static void main(String[] args){
  ClassTest2 test = new ClassTest2(3);
   int sum1 = test.getArrPlusResult(new int[]{1,2,3});
  long sum2= test.getArrPlusResult(new long[]{1,2,3});
  test.ClassTest2();
  System.out.println("getArrPlusResult(int[] arr): result"+sum1);
  System.out.println("getArrPlusResult(int[] arr): result"+sum2);
 }
}
四. 类的继承

 子类继承或者说派生自父类。子类可以享有父类的方法。在初始化一个子类对象的时候，调用其中的方法，如果该方法中在父类也有定义，
 并且参数列表不同，则调用到的是子类特有的方法。否则调用的是父类方法。
 注意：如果仅仅是他们的返回值类型不同，则会出现编译错误。