【JavaSE】P33~P113 方法，重载，数组，对象，构造器，this关键字，数组和对象的内存图，JavaBean

1 方法

方法定义及调用

• 方法名命名规则和变量一样，小驼峰。

public static void 方法名（）{
方法体
}

修饰符 返回值类型 方法名称（参数类型 参数名称，……）{
	方法体；
	return 返回值；
}

参数列表，逗号隔开
注意：
1.方法定义的先后顺序无所谓
2.方法不能嵌套包含
3.方法定义好以后，不会执行的，如果想执行，一定要进行方法的调用。
方法调用

• 调用方法格式：

方法名称（）；

JShell简单使用（要求Java9以上）

注意：jshell里不能复制粘贴，但可以鼠标选中之前的部分指令，然后右键在当前输入行点击会自动粘贴
win+R打开搜索cmd
敲：

jshell
System.out.println("Hello JShell");
int b = 20;
System.out.println("结果是：" + b * 10);
/exit

方法语句流程控制及注意事项

选择

表达式只分true或false

if(表达式){
	语句；
}else{
	语句；
}

if(表达式){
	语句；
}else if(表达式){
	语句；
}else if(表达式){
	语句；
}……

其中（）的值只能是基本类型：byte/short/int/char,引用类型：String字符串，enum枚举。
case后的常量必须与（）的值类型一致，其中整型和char可以兼容

switch（一个值）{
	case 常量：
		语句；
		break;
	default: //
		break;

}

• switch

1. 格式

switch(变量）{
case 常量值1：
	语句1；
	break;
case 常量值2：
	语句2；
	break;
case 常量值3：
	语句3；
	break;
case 常量值4：
	语句4；
	break;
default:
	语句5；
	break;
}

2. 穿透的switch语句

• 多个case后的数不可重复（编译错）
• switch小括号内只能是下列数
  基本：byte/short/char/int
  引用：String字符串，enum枚举
• 格式灵活，前后顺序可颠倒，break可省略
  省略后不会跳出switch直到穿透下一个顺位case有break再跳出

匹配哪一个case就从哪一个位置向下执行，直到遇到了break或整体结束

循环

size控制循环次数

for(int i = 0; i < size; i++){
	语句；
}

while(表达式){
	语句；
}

do{
	语句；
}while(表达式);

• switch case 匹配到哪一个case就从哪一个位置向下执行，直到遇到break或整体结束

• 三种循环里(for,while,do-while)，若条件从未满足，do -while 至少会执行一次

• 在IDEA中，delete一个Module，外部打开project打开还是存在的，怎么导入一个外部保存的Module
  file-project structure + import module setup sdk即可

• 方法的三种调用形式，单独调，打印调，赋值调。void返回值类型只能单独调

• 一个方法中可以有多个return，但必须保证同时只走一个return

• ❤重载： 多个方法的名称一样，但参数列表不一样（数据类型or顺序） 与参数名称无关，与返回值类型无关。调用时，通过参数列表区分

• break语句，在switch中用，执行后switch语句结束。在循环中用，执行后打破循环

• continue语句，继续，一旦执行立刻跳过当前次循环内容，马上开始下一次循环

方法的重载

重载：对于功能类似的方法，参数列表不同
多个方法的名称一样，但参数列表不一样
调用时，以不同参数区分

方法重载与下列因素相关：
1.参数个数不同
2. 参数类型不同
3. 参数的多类型顺序不同
无关因素：
1.与参数名称无关
2.与返回值类型无关

2 数组

三种初始化方式

• 动态初始化（指定长度）、静态初始化（指定内容）、省略式静态初始化
  静态初始化可以省略写，但不可分为两步写。另外两个可以分为两步写

		int[] array1 = new int[3];
        int[] array11;
        array11 = new int[4];

        int[] array2 = new int[]{3,4,5};
        int[] array22;
        array22 = new int[]{3,4,5};
        
        int[] array3 ={1,2,3};

• 打印数组的方法 Arrays.toString(arr) 格式：[1,2,3]
• 光定义没有new就是没初始化
• 数组一旦创建，程序运行期间，长度不可改变
• String也是，不会改变，属于常量，如果改变一定是引用改变了指向的地址
• 数组作为参数和返回值都是传递地址

访问数组元素进行获取，直接打印数组名称，得到的是数组对应的，内存地址哈希值。访问数组名称：数组名称[索引值]
访问数组元素进行赋值，没赋值默认

整数：0
浮点：0.0
字符：‘\u0000’
boolean： false
引用：null

数组在内存中的存储内存图

• ❤方法的运行要进栈，存放局部变量，方法的参数，或者是方法{}内部的变量。局部变量不赋值无法使用，没有默认值
• 凡是new出来的东西，都在堆当中，堆内存中的东西都有一个地址值，16进制，都有默认值
• 方法区：存储.class信息，包含方法的信息。

1. 定义数组并赋值时的内存图

 int[] arr = new int[3];//只规定长度，动态初始化
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        arr[1] = 10;
        arr[2] = 20;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

2.两个引用指向同一个数组

 //两个引用指向同一个数组的内存图
        int[] arr2 = new int[]{1, 2, 3, 4};
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);

        int[] arr3 = arr2;
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);

• 数组一旦创建，运行期间不可改变。

int[] arrC = new int[3];
arrC = new int[5];//长度改变
//等于创建了一个新的数组

3 对象

面向过程：需要实现一个功能的时候，详细处理每一个细节
面向对象：找一个已经具有该功能的人，来帮我做事

• 成员变量是直接定义在类当中的，在方法外边

• 对象的创建及使用
  1.导包，import 包名称.类名称对于和当前类属于同一个包的情况，省略导包语句不写。注意：使用同一个包下类中的静态方法时若不想写类名.方法名调用，要导包import static 包名称.类名称.方法名或*指所有方法。但静态方法中调用非静态方法，一定要通过对象调用
  2.创建，格式： 类名称 对象名 = new 类名称();
  3.使用，对象名.成员变量名，对象名.成员方法名（参数）
  
  

对象内存图

• 一个手机类及其测试练习

public class Phone {
    public String brand;
    public double price;
    public String color;

    public Phone() {
    }

    public Phone(String brand, double price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    
    //成员方法
    public void call(String who){
        System.out.println("给"+who+"打电话");
    }
    public void sendMessage(){
        System.out.println("发信息");
    }
}

public class Demo01PhoneOne {
    public static void main(String[] args) {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8799.0;
        one.call("小明");
        one.sendMessage();
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
    }
}

运行结果：

给小明打电话
发信息
苹果
8799.0
null

• 两个对象使用同一个方法
  根据调用方法的顺序，依次压栈运行方法，栈中后调用的方法在main方法之上（main方法没运行完，所以还在栈中）。若方法体运行完毕则出栈
  可见两对象调用同一个方法时，不产生任何联系，
  要产生联系：两个对象名称（对象的引用名）指向同一个对象（对象空间），即one和two指向的地址相同，相当于一个对象两个名称。
  

• 使用对象作为方法的参数或返回值同理
  传递的都是对象的地址，每次new一个对象都在堆中，栈中运行方法要赋值或用到对象，就赋值为该对象空间的地址，根据地址访问到对象空间进行使用。

  Getter/Setter快捷写法

• Code -> Generate或者alt + Insert

• Generate -> Constructor 为构造器
  -> Getter 方法
  -> Setter 方法

无参构造选 select none，全参构造 ctrl多选所有参数

• Getter同理，生成哪个成员变量的方法选哪个变量。Ctrl多选

this 关键字

• 当方法的局部变量和累的 成员变量重名时，“就近原则”优先使用局部变量
• 要访问本类当中成员变量，用 this.成员变量名
• 通过谁调用的方法，谁就是this

构造方法

是专门用来创造对象的方法，当用new来创建对象时，就是在调用构造方法
格式：

public 类名称（参数类型  参数名称）{
	方法体
}

1.构造方法的名称必须和所在类名完全一样
2.构造方法不要写返回值类型，void都不写
3.不能return一个具体的返回值，可以return;表结束
4.如果没写任何构造方法，编译器会默认送一个构造方法，没有参数，方法体什么都不做
5.一旦编写了至少一个构造方法，那么编译器将不再送这个默认无参构造。
6.构造方法可重载

JavaBean的四个标准

1. 所有成员变量都要使用private修饰
2. 编写一个无参数的构造方法
3. 写一个全参构造器，一个无参构造器
4. 每一个成员都要写一对getter,setter

对于基础类型boolean写getter方法需要写为isXxx，其他都写为getXxx，setter统一写setXxx

---

二、编程练习计算

1、流程语句，方法的使用

用 if 替换三元运算符，int max = a > b ? a : b;

A:

int max;
        int a = 5, b = 8;
        if(a > b){
            max = a;
        }else{
            max = b;
        }

switch case 语句判断对错并修改

String str1 = "哈哈";
        String str2 = "呵呵";
        char ch = '9';
        switch(ch){
            case 4:
                break;
            case 4:
                break;
            case '%':
                break;
            case str1:
                break;
            default:
                break;
        }

A:

		String str1 = "哈哈";
        String str2 = "呵呵";
        char ch = '9';
        switch(ch){
            case 4: //正确，因为字符有ascii码，可以互通
                break;
             ● case 4: //多个case后的数不可以重复
                break;
            case '%':
                break;
             ● case str1: //错，表达式类型时char ，case后只能跟char或者整数类型
                break;
            default:
                break;
        }

swith case 判断运行结果

		char ch = '4';
        switch(ch){
            case 4:
                System.out.println(4);
            case 5:
                System.out.println(5);
                break;
            case '%':
                break;
            case '9':
                 System.out.println(9);
            default:
                break;
        }

A：输出

4
5

穿透switch，从匹配的case中进入，但break才退出

求1~100之间的偶数和

public int evenSum(){
        int sum = 0;
        for(int i = 1; i <= 100; i++){
            if(i % 2 != 0){
                continue;
            }
            sum += i;
        }
        return sum;
    }

打印一个矩阵用方法 public static void rectangle();

public static void rectangle(){
        for(int i = 0; i < 8; i++){
            System.out.printf("*");
        }
        System.out.println();
        for(int i = 0; i < 6; i++){//6行
            System.out.printf("*");
            for(int j = 0; j < 6; j++){//6列空格
                System.out.printf(" ");
            }
            System.out.println("*");

        }
        for(int i = 0; i < 8; i++){
            System.out.printf("*");
        }
        System.out.println();

    }

打印指定次数hello world，带参数方法

A:

public static void helloTime(int times){
        for(int i = 0; i < times; i++){
            System.out.println("Hello,World");
        }
    }

helloTime(5);

写重载方法，比较两数是否相同，参数类型，两个byte，两个int，两个long

A:

	public static boolean isEquals(byte num1, byte num2){
        return num1 == num2 ? true : false;
    }
    public static boolean isEquals(int num1, int num2){
        return num1 == num2 ? true : false;
    }
    public boolean isEquals(long num1, long num2){
        return num1 == num2 ? true : false;
    }

		System.out.println(isEquals(5,5));//true
        System.out.println(new Code01().isEquals(345L,1234L));//false
        byte s1 = 8, s2 = 0;
        System.out.println(isEquals(s1, s2));//false

判断哪些是重载关系

public boolean isEquals(int num1, byte num2);
public int isEquals(byte num2, int num1);
public void isEquals(int num1, int num2)
public static boolean isEquals(int num1, int num2)
public boolean isEquals(long num1, long num2)

public static void open()
public static void open(int a)
stats void open(int a, int b)
public static void open(souble a, int b)
public statc void open(int a, double b)
public void open (int i, double d)
publid static void OPEN()
public static void open(int i, int j)

A:
方法重载与下列因素相关：
1.参数个数的不同
2.参数类型的不同
3.参数的多类型顺序不同
无关因素：
1.与参数名称无关
2.与返回值类型无关

public boolean isEquals(int num1, byte num2)//正确重载
public int isEquals(byte num2, int num1)//正确重载
public void isEquals(int num1, int num2)//错误，和第4行冲突
public static boolean isEquals(int num1, int num2)//和第3行冲突
public boolean isEquals(long num1, long num2)//正确

7 public static void open()//正确重载
8 public static void open(int a)//正确
9 static void open(int a, int b)//错误，与14行冲突
10 public static void open(double a, int b)//正确
11 public statc void open(int a, double b)//错误，与12行冲突
12 public void open (int i, double d)//和11行冲突，重复方法，不是重载
13 publid static void OPEN()//方法名不同，不重载，独立方法
14 public static void open(int i, int j)//和9行冲突，重复方法

成员变量和局部变量，判断输出结果

	public class Demo01 {
    	int num1 = 1;

    public void method(){
        int num1 = 2;
        this.num1 = 3;
        System.out.println(num1);
        System.out.println(this.num1);
    }

    public static void main(String[] args) {
        int num1 = 4;
        //System.out.println(this.num1);
        System.out.println(num1);
        
        new Demo01().method();
    }
}

A:
1.定义的位置不一样
局部：在方法内部
成员：在类中，方法外
2.作用范围不一样
局部：只有方法中
成员：整个类中
3.默认值不一样
局部：无默认值
成员：有默认值

结果，因为静态方法不能使用this因为是直接调用，不是用对象调用的，没有对象就没有this。
非静态方法中，若成员变量和局部变量同名，就近原则调用局部变量。this.调用所在类的成员变量

4
2
3

2、数组

写3种初始化数组的方式，并且分为两步

A:
动态初始化，即只定义长度，后续一个个填充元素内容 int[] arr1 = new int[6]; arr[0] = 1; arr[2] = 8;分两步 int[] arr1; arr1 = new int[6];
静态初始化 int[] arr2 = new int[]{3,4, 52 ,54,32};分两步int[] arr2; arr2 = new int[]{34,34,32,4};
静态初始化省略写法int[] arr3 = {2,3,4};不可分为两步

打印数组，1，自己写，数组作为参数 2，用系统方法

A:
系统的

System.out.println(Arrays.toString(arr3));

自己写
for each是只能访问数组元素，不能访问下标值

	for(int n : arr3){
            System.out.print(n + ",");
        }
        System.out.println();

	for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]);
            if(i == arr2.length - 1) {
                System.out.println();
                continue;
            }
            System.out.printf(",");

        }

写一个方法将数组中@都改为￥

A:注意，数组长度在运行期间不可改变，但可以改变元素内容
没赋值的数组元素为默认值，boolean为false,引用为null，字符‘\u0000’
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成了大括号中的具体数值

 public static void changeChar(char[] arr){
        for(int i = 0; i < arr.length; i++){
            if(arr[i] == '@'){
                arr[i] = '￥';
            }
        }
    }

 		char[] arr = {'3','@',54,89,'~','@',34};
        changeChar(arr);
        System.out.println(Arrays.toString(arr));

分析下列程序运行过程中，内存图存储情况，画图

		char[] arr = new char[3];//只规定长度，动态初始化
		arr[1] = '9';
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        arr[1] = 'y';
     

A:

改变数组arr1的长度和内容,画内存图

A:
数组长度不可改变，如果改变说明数组引用指向了另一个数组，等于创建了一个新的数组
类似如图，只是两个数组引用名称指向同一个内存空间

求数组中最值

A:

 		int max = arr1[0];
        for (int i = 0; i < arr1.length; i++) {
            if(arr1[i] < max){
                max = arr1[i];
            }
        }

数组元素反转

A:

		int tmp;
        for (int i = 0; i < arr1.length/2; i++) {
            tmp = arr1[i];
            arr1[i] = arr1[arr1.length - i - 1];
            arr1[arr1.length - i - 1] = tmp;
        }
        System.out.println(Arrays.toString(arr1));

3、对象

创建一个Phone类并使用，分析内存情况，两对象使用同一个成员方法

包含属性 品牌，价格和颜色，两个构造器一个无参一个全参，成员方法，1.给who打电话，2.发信息。
创建两个该对象，两对象使用同一个方法，调用初始化属性打印并调用方法，
画该过程内存图
A:

public class Phone {
    //包含属性 品牌，价格和颜色，两个构造器一个无参一个全参，成员方法，1.给who打电话，2.发信息。

    private String brand;
    private double price;
    private String color;

    public Phone(){

    }
    Phone(String brand, double price, String color){
        this.brand = brand;
        this.price = price;
        this.color = color;
    }

    public static void call(String who){
        System.out.println("给" + who + "打电话");
    }
    public static void send(){
        System.out.println("发短信");
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public double getPrice() {
        return price;
    }

    public String getColor() {
        return color;
    }
}

public class Demo01Phone {
    public static void main(String[] args) {
        //创建两个该对象，两对象使用同一个方法，调用初始化属性打印并调用方法，
        //画该过程内存图
        Phone one = new Phone();
        Phone two = new Phone("三星", 7999.0, "白");

        one.setPrice(3999.0);
        System.out.println(one.getBrand());
        System.out.println(one.getPrice());
        System.out.println(two.getBrand());
        one.call("barbie");
        two.call("ken");
    }
}

分析内存中过程：
方法区：类的.java文件编译后生成.class的字节码文件，包含方法的信息

栈：方法的运行就是进栈，存放局部变量，方法的参数，或者是方法{}内部的变量。局部变量不赋值无法使用，没有默认值。运行语句到调用方法，该方法体进栈，是对象的方法，所以从堆中new的对象里找方法信息，堆中方法又从方法区找方法信息。方法运行完毕就出栈，再依次执行后续的方法，进栈出栈。

堆：堆内存的东西都有一个地址值，16进制，都有默认值

两对象使用同一个成员方法时，两对象不产生任何联系。
两个对象要产生联系，可以两个对象名称（对象的引用名）指向同一个对象（对象空间）。

Phone one = new Phone();
Phone two = one;

使用对象类型作为方法的参数，分析内存图

使用对象类型作为方法的返回值，分析内存图

public static void method1(Phone param){
        System.out.println(param.getBrand());
        System.out.println(param.getPrice());
        System.out.println(param.getColor());
    }
    public static Phone method2(String brand){
        Phone p = new Phone(brand, 0.0, null);
        return p;
    }

    public static void main(String[] args) {
        //正常生成对象
        Phone p1 = new Phone("华为", 7999.0, "曜石黑");

        //对象作为方法参数,打印对象的成员变量
        method1(p1);

        //对象作为方法返回值
        Phone p2 = method2("苹果");
        System.out.println(p2.getBrand());

    }

this关键字，判断输出结果

4、构造器

判断new 对象是否成功及原因

不同类的构造器写法

public class Class0 {
}

public class Class1 {
    public Class1() {
        System.out.println("类Class1的无参构造");
    }
}

public class Class2 {
    private Class2(){
        System.out.println("类Class2的无参构造");
    }
}

public class Class3 {
    public Class3(){
        System.out.println("类Class3无参构造");
    }
    public Class3(int num){
        System.out.println("类Class3的有参构造" + num);
    }
}

public class Class4 {
    public Class4(int num){
        System.out.println("类Class4的有参构造" + num);
    }
}

判断new的使用构造器对错

Class0 c0 = new Class0();
Class1 c1 = new Class1();
Class2 c2 = new Class2();
Class3 c3 = new Class3();
Class3 c33 = new Class3(99);
Class4 c4 = new Class4();

A:

		Class0 c0 = new Class0();//正确，因为啥构造器都没写，系统默认一个方法体空的无参构造器
        Class1 c1 = new Class1();//正确，输出无参
        //Class2 c2 = new Class2();//错误，因为构造器修饰符private，只能在类内部使用
        Class3 c3 = new Class3();//正确，输出无参
        Class3 c33 = new Class3(99);//正确，输出有参
        //Class4 c4 = new Class4();//错误，只写了有参构造，系统就不默认赠送无参构造，就没有无参构造器