JAVA-笔记2

一. java 三大流程控制
1. 顺序控制
依次执行我们的代码。
2. 条件控制
int a = 0;
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.如果满足条件只需要执行一行代码，{}也是可以省略的，但是不建议这么做.

相关代码：

public class Ti1 {public static void main(String[] args) {intscore=60;if(score>=90){System.out.println("iphone x");}else if(score>=70 && score<90){System.out.println("iphone s");}else if(score>=60 && score<70){System.out.println("xiao mi");}}}

(4)switch case
结构:
switch(判断值){
case 值1:
break;
case 值2:
break;
.......
case 值n:
break;
default:
}
条件控制语句来说：

彼此可以嵌套使用的

建议: 虽然条件判断语句可以彼此嵌套，而且也没有嵌套层数的限制，但是过多的嵌套很影响可读性。
所以要避免过多的嵌套，一般最多建议嵌套3层。

相关代码

import java.util.Scanner;public class Ti2 {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("今天是不是周末：");boolean isWeekend=sc.nextBoolean();System.out.println("今天是否下雨");boolean isRain=sc.nextBoolean();System.out.println("参加人数是多少：");int joinPresonNum=sc.nextInt();if(isWeekend){if(isRain){if(joinPresonNum>5){System.out.println("打游戏");}else{System.out.println("看书");}}else{System.out.println("室外活动");}}else{System.out.println("上课");}}}

3. 表达式的类型:
int a = 5;
a*3 (结果15)
表达式的输出类型为表达式计算结果的类型.
double num = 1.5;
num * 4 (6.0, 表达式最终被当做的类型就是double类型)

4.循环控制
a. while 循环
结构:
while(循环条件){
//循环实现的代码
}

public class ClassTestDemo1{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);}}

b. do .. while循环
结构:
do{
//实现的代码

}while(循环的条件);

public class DoWhile{public static void main(String[] args){int maxNum = 10;int minNum = 11;//打印1到10之间的自然数do{System.out.println(minNum);minNum++;}while(minNum<=maxNum);}}

c. for 循环
使用率最高的;
结构:
for(循环变量初始化 ;循环条件判断; 循环变量的改变){
//循环需要实现的逻辑

}

public class ForDemo1{public static void main(String[] args){int minNum = 1;final int MAX_NUM = 50;int sum = 0;/*for(int i=1;i<=MAX_NUM;i++){if(i%2 == 0){sum+=i;}}*//*int i = 0;for(;i<=MAX_NUM;){if(i%2==1){sum+=i;}i++;}*/for(int i = 0,num =0;i<100;i+=4,num++){System.out.println("i:"+i);System.out.println("num:"+num);}}}

d. foreach 循环(不是一个常规的java提供的循环的方式，他只是java提供的一种语法糖)
foreach: 对一种循环方式的命名，常规循环的简化方式.
语法糖： 针对基本的语法，提供了一种简化的实现方式.
补充知识点:
俩个关键字: 应用到循环控制中，continue的含义是跳出当次的循环，break的含义是跳出整个循环
continue:
在循环的代码体中，如果遇到continue, 则会跳出当次循环，循环体内continue之后的代码都不会执行，并且循环变量进行一次改变操作，

之后再次进行条件判断，如果满足条件，则进入循环，否则直接结束循环; 跳出的仅是continue外层直接包裹的循环.

public class ContinueDemo1{public static void main(String[] args){int sum = 0;int times = 0;//1到50之间所有偶数的和for(int i = 1;i<=50;i++){times++;if(i%2 == 0){sum+=i;}else{continue;}System.out.println("一次循环结束");}System.out.println(sum);System.out.println(times);}}

break:
在循环的代码体中，如果遇到break,则会跳出本循环代码块，break后的代码不会执行。并且整个循环的过程结束。
break后退出的循环也是直接包围break的循环
循环的嵌套:
System.out.println("*"); //输出，会默认换行
System.out.print("*"); //输出，不会换行
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,能够让我们拿到数组的长度.
课堂练习:
定义一个保存5个整形的数组，依次赋值为 1--5.

最终再依次打印出数组保存的每个元素(要求打印的时候按照倒序)

public class Ti {public static void main(String[] args) {int [] arr=new int[5];for(int i=0;i<arr.length;i++){arr[i]=i+1;}for(int i=arr.length-1;i>-1;i--){System.out.println(arr[i]);}}}

初始化:
动态初始化:
我们在定义一个数组和对数组进行赋值的操作，我们分开来执行。
静态初始化:
我们在定义一个数组的同时，进行数组的初始化
//动态初始化
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. 数组保存的元素类型一旦指定，也是不可以改变，并且只能保存该类型的元素
课堂练习:
第一个一个保存10个整形元素的一维数组，其中值为1到10,我们分别求 这十个数的和，以及十个数的平均值，
以及俩俩相邻的差，最终的和。

public class Ti {public static void main(String[] args) {int [] arr={1,2,3,4,5,6,7,8,9,10};int sum=0;double avrsum=0;int sum1=0;for(int i=0;i<arr.length;i++){sum+=arr[i];}avrsum=(double)sum/arr.length;System.out.println("sum="+sum);System.out.println("avrsum="+avrsum);for(int i=1;i<arr.length;i++){sum1+=arr[i]-arr[i-1];}System.out.println("sum1="+sum1);}}

二维数组:
声明:
类型 [][] 数组名称;
int [][] arr;
初始化:
a.动态初始化
int [][]arr = new int[3][];
b.静态初始化
int [][]arr = {{1,2,3},{2,3,4,5}};
length:
这个属性拿到二维数组的长度。
练习题；二维数组的遍历输出

import java.util.Arrays;public class ArrayDemo5{public static void main(String[] args){int[][] arr= new int[][]{{1,2,3},{3,4,5},{5,6,2}};int[][][] arr1= new int[][][]{{1,2,3},{3,4,5},{5,6,2}};for(int i=0;i<arr.length;i++){for(int j=0;j<arr[i].length;j++){System.out.println(arr[i][j]);}}}}

二. 方法
定义: 实现一个功能的代码片段的封装。
[修饰符...] 返回值类型 方法名称(形参的列表){
//方法中实现的逻辑
}
形参列表: 方法接收外部传入的数据的接收媒介.
返回值: 方法执行结束之后，返回的值的类型。
如果方法不需要返回任何的值，那么我们的方法返回类型写作void.
在方法里返回一个值，需要用到 return. 
形参列表:
当我们定义了一个方法之后，去调用方法的时候，一定要注意我们传递给方法的入参的类型和数量，一定要一一对应。
唯一确定一个方法:
关注点:
a.方法名是否一致
b.形参列表的所有参数类型和数量是否一致。 对于形参变量的命名，完全是没有关系的.
c.返回值的类型
  可以是基本类型，也可以是引用类型。
注意:
a.一旦明确指定了方法的返回类型(非void),那么一定要保证最终方法可以成功的返回我们对应的返回类型的数据.
b.关于void返回类型
如果我们不主动的添加return语句，在执行的时候，也会帮我们自动添加return.我们在实现void类型的方法的时候，主动添加一个return也是没有问题。 
java预编译的特点.
方法参数的传递:

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

三.类

a.定义
类：是封装对象的属性和行为的载体。具有相同属性和行为的类实体，可以称为类。
b.类由两部分组成

(1)成员变量
修饰符...]type name[=默认值]

(2)方法
c.类之间的关系

(1)关联关系(最弱)

(2)继承关系(一个子类只能有一个父类)

(3)聚合(关系聚合和组合

)

1. 关于变量的作用域:
成员变量:
类的属性
局部变量:
方法中定义的变量或者是方法的形式参数。
对于java语言来说，作用域控制是通过块来控制的.
块的概念: 一对{} 包裹，该代码片段就称为 一块.
对于某个块内定义的变量：
a.对于当前的块，不能再定义同名的变量,即使类型不同也不行。
b.对于当前的块，定义了某个变量，在块外不能够访问到块中定义的变量
如果存在块的嵌套:
那么外层块定义的变量，在内层块中是可以访问到的.

2. 构造方法(构造器)
1）.类中特殊的方法，对于定义来讲，它的方法名必须和类名一模一样，并且不返回任何的值，主要不能添加void.
2）.在new（创建一个对象的时候），一定会去调用它的构造方法。 但是如果我们没有自己添加自己定义的构造器的话，编译器会帮我们
偷偷的添加一个默认的构造器:
类名(){

}
如果我们主动添加一个默认的构造器，那么在创建对象的时候，通过new 类名(); 会调用我们自己添加的默认构造器.

public class Person{int age;int height;int weight;boolean sex;Person(int ageParm,int heightParm,int weightParm,boolean sexParm){age = ageParm;height= heightParm;weight = weightParm;sex = sexParm;}void getSex(){if(sex){System.out.println("男孩");return;}System.out.println("女孩");}public static void main(String[] args){Person green = new Person(40,170,65,true);Person yellow = new Person();green.getSex();}}

3）.注意：当我们主动添加了一个包含参数列表的构造器，并且没有主动添加默认的构造器，则再通过new 类名(); 就会遇到编译问题.
3. 方法重载 overload
1）. 对于同名的方法，具有不相同的参数列表，我们在访问的时候，通过调用方法传入不同的参数列表，就可以找到我们特定的方法。
2）. 当我们定义多个重载的方法的时候，在编译阶段的话，编译器可以根据我们方法形式参数数量以及类型来区别不同的方法，执行阶段可以
根据我们调用的时候传入的参数列表， 仅仅拥有不同的返回值类型，是不被视为重载的。

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