2020-07-21

7-17笔记整理

数组

数组概述和定义格式说明

为什么要有数组

• 现在要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工

• 用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦

• 为了解决这种问题，java就提供了数组供我们使用

• 结论：

  数组是存储多个变量（元素）的东西（元素）

  这多个变量的数据类型要一致

数组概念

• 数组是存储同一数据类型多个元素的集合，也可以看成是一个容器
• 数组既可以存储基本数据类型，也可以存储引用数据类型

数组定义格式

• 格式1：数据类型[ ] 数组名；

• 格式2：数据类型 数组名[ ]；

• 举例：

  int[ ] a； 定义了一个int类型的数组a；

  int a[ ]； 定义了一个int类型的a数据；

  推荐使用第一种定义方式

数组的初始化-动态初始化

什么是数组的初始化

• java中的数据必须先初始化，然后才能使用
• 所谓初始化：就是数组中的数据元素分配内存空间，并为每个数组元素赋值

初始化的分类

• 动态初始化：只指定长度，由系统给出初始化值
• 静态初始化：给出初始化值，由系统决定长度

动态初始化的格式

• 数据类型[ ] 数组名=new 数据类型[数组长度]；
• 数组长度其实就是数组中元素的个数。
• 举例：int[ ] arr=new int[3]；定义了一个int类型的数组arr，这个数组可以存放3个int类型的值
• 数组定义完之后，每个元素会分配有索引（角标），从0开始

public class demo {
    //输出数组名称和数组元素
    public static void main(String[] args) {
        int[]arr=new int[5];
        System.out.println(arr);//输出数组名称获取到的是地址值
        System.out.println(arr[3]);//输出数组中第4个元素，初始化是0
    }
}

JAVA中的内存分配以及栈和堆的区别

java虚拟机再执行java程序的过程中会把它管理的内存划分成若干个不同的数据区域

• 栈：存放的是局部变量

  局部变量：在方法定义中或者方法声明上的变量都是局部变量

• 堆：存放的是所有new出来的东西

  特点：

  • 每一个new出来的东西都会为其分配一个地址值

  • 每一个变量都有一个默认值

    byte，short，int，long —— 0

    float，double —— 0.0

    char —— ‘\u0000’

    boolean —— false

    引用数据类型 —— null

  • 使用完毕就变成了垃圾，等待垃圾回收器对其回收

• 方法区：（面对对象部分讲解）

• 本地方法区：（和系统相关）

• 寄存器：（cpu使用）

数组内存图解-一个数组

public class demo {
    //定义一个数组，输出名称和元素值，赋值后再进行输出
    public static void main(String[] args) {
        int[]arr=new int[3];//定义一个数组
        System.out.println(arr);//输出数组名称也就是地址值
        System.out.println(arr[2]);//输出其中元素，初始化为0
        arr[0]=10;
        arr[1]=15;
        arr[2]=20;//给数组中的元素赋值
        System.out.println(arr);//输出数组名称。地址值不会发生变化
        System.out.println(arr[2]);//此时输出的是经过赋值的元素
    }
}

数组内存图解-两个数组

public class demo {
    //定义两个数组，输出名称和元素值，赋值后再进行输出
    public static void main(String[] args) {
        int[]arr1=new int[2];
        int[]arr2=new int[2];//new两个不同数组
        System.out.println(arr1);//输出数组名称也就是地址值
        System.out.println(arr1[0]);//输出其中的元素，初始值为0
        System.out.println(arr2);//不同的数组地址值不同
        System.out.println(arr2[0]);
        arr1[0]=10;
        arr1[1]=15;
        arr2[0]=20;
        arr2[1]=25;//给元素赋值
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr2);//地址值不会发生改变
        System.out.println(arr2[0]);
    }
}

数组内存图解-三个数组第三个引用

public class demo {
    //定义三个数组，进行引用
    public static void main(String[] args) {
        int[]arr1=new int [1];
        arr1[0]=10;
        System.out.println(arr1);
        System.out.println(arr1[0]);

        int[]arr2=new int[1];
        arr2[0]=20;
        System.out.println(arr2);
        System.out.println(arr2[0]);

        int[]arr3=arr1;//把第一个数组的地址值赋给第三个数组
        arr3[0]=50;
        System.out.println(arr3);
        System.out.println(arr1[0]);//第三个数组的地址值指向第一个数组，所有可以通过给第三个数组赋值来改变第一个数组中元素的值

    }
}

数组的初始化-静态初始化及内存图

静态初始化的格式

• 格式：数据类型[ ] 数据名=new 数据类型[ ]{元素1，元素2，……}

  举例：int[ ] arr=new int[ ]{1,2,3}；

• 简化格式：数据类型[ ] 数据名={元素1，元素2……}；

  举例：int[ ] arr={1,2,3}；

public class demo {
    //输出数组名称和数组元素
    public static void main(String[] args) {
        int[]arr=new int[]{10,15,20,25};//给出初始值
        System.out.println(arr);//输出数组名称获取到的是地址值
        System.out.println(arr[2]);//输出数组元素初始值
    }
}

数组操作的两个常见小问题（越界和空指针）

public class demo {
    //数组越界
    public static void main(String[] args) {
        int[]arr=new int[]{10,15,20,25};
        //ArrayIndexOutOfBoundsException:数组索引越界异常
        //原因：你访问了不存在的索引
        //数组中只有4个元素，只能根据索引0-3进行输出
        System.out.println(arr[4]);
    }
}

public class demo {
    //空指针异常
    public static void main(String[] args) {
        int[]arr=new int[]{10,15,20,25};
        arr=null;
        //NullPointerException:空指针异常
        //原因：数组已经不在指向内存堆了，而你还用数组名去访问元素
        System.out.println(arr[2]);
    }
}

数组的操作

遍历

public class demo {
    //数组的正向遍历
    public static void main(String[] args) {
        int[]arr=new int[]{10,15,20,25,11,34,24,64,25,75,33};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

快捷键：数组名称.fori

public class demo {
    //数组的反向遍历
    public static void main(String[] args) {
        int[]arr=new int[]{10,15,20,25,11,34,24,64,25,75,33};
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.println(arr[i]);
        }
    }
}

快捷键：数组名称.forr

获取最值

public class demo {
    //获取数组中的最大值
    public static void main(String[] args) {
        int[]arr=new int[]{10,15,20,25,11,34,24,64,25,75,33};
        int max=arr[0];//定义一个参照值
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max){
                max=arr[i];//把较大的赋给max
            }
        }
        System.out.println(max);
    }
}

public class demo {
    //获取数组中的最小值
    public static void main(String[] args) {
        int[]arr=new int[]{10,15,20,25,11,34,24,64,25,75,33};
        int min=arr[0];//定义一个参照值
        for(int i=0;i<arr.length;i++){
            if(arr[i]<min){
                min=arr[i];//把较小的赋给min
            }
        }
        System.out.println(min);
    }
}

反转

public class demo {
    //数组首尾元素依次交换
    public static void main(String[] args) {
        int[]arr=new int[]{10,15,20,25,11,34,24,64,25,75,33};
        for (int i = 0; i < arr.length; i++) {
            if(i<arr.length/2){
                int t;//定义中间变量进行交换
                t=arr[i];
                arr[i]=arr[arr.length-1-i];
                arr[arr.length-1-i]=t;
                System.out.println(arr[i]);// 元素在数组前一半时进行首位交换
            }else{//后一半不能再进行交换啦，不然就换回去了
                System.out.println(arr[i]);//后半部分已经交换好，直接打印即可
            }
        }
    }
}

查表法

import java.util.Scanner;
public class demo {
    //键入索引查找对应星期
    public static void main(String[] args) {
        String[] day = new String[]{"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
        Scanner today = new Scanner(System.in);
        System.out.println("请输入一个数字");
        int i = today.nextInt();
        System.out.println(day[i]);
    }
}

基本查找

import java.util.Scanner;
public class demo {
    //查找指定元素第一次在数组中出现的索引
    public static void main(String[] args) {
        int[]arr=new int[]{1,3,5,7,9,2,4,6,8};
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个数1-9");
        int i = sc.nextInt();
        for (int n = 0; n < arr.length; n++) {
            if(arr[n]==i){
                System.out.println(n);//输出的是对应元素的索引
            }
        }
    }
}

二维数组概述和格式

二维数组概述

• 每个班有许多名学生，所以可以用数组来存储，而我们又同时有很多个班
• 这个也应该用同一个数组来储存，如何表示这样的数据呢？java提供了二维数组供我们使用
• 由此可见，其实二维数组就是每一个元素为一维数组的数组

二维数组格式-1

• 数据类型[ ] [ ] 变量名=new 数据类型[m] [n]；

  m表示这个二维数组有多少个一维数组，必须写上

  n表示每一个一维数组的元素个数，可选

• 举例

  int[ ] [ ]arr=new int[3] [2]；

  定义了一个二维数组arr

  这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]

  每个一维数组有2个元素，可以通过arr[m] [n] 来获取

  • 表示获取第m+1个一维数组的第n+1个元素

注意事项

• 以下格式也可以表示二维数组

  数据类型 数组名[ ] [ ]=new 数据类型[m] [n]；

  数据类型[ ] 数组名[ ]=new 数据类型[m] [n]；

  这两种格式不推荐使用

• 注意下面定义的区别

  int x，y；

  int[ ] x，y[ ]；

  区别是：

  • int[ ] x，y[ ]；定义了两个数组，一个是一维数组x，一个是二维数组y

    x=new int [3]；

    y=new int [3] [ ]；

public class demo {
    //定义二维数组，输出二维数组名称，输出每个一维数组名称，输出二维数组中的两个元素
    public static void main(String[] args) {
        int[][]arr=new int[3][2];
        System.out.println(arr);//输出二维数组的名称也就是二维数组的地址值
        System.out.println(arr[0]);//输出第一个一维数组的地址值
        System.out.println(arr[1]);//输出第二个一维数组的地址值
        System.out.println(arr[2]);//输出第三个一维数组的地址值
        System.out.println(arr[0][0]);//输出二维数组中第一个一维数组的第一个元素
        System.out.println(arr[1][1]);//输出二维数组中第二个一维数组的第二个元素
    }
}

二维数组格式-2

二维数组格式

• 数据类型 [ ] [ ] 变量名=new 数据类型[m] [ ]；

  m表示这个二维数组有多少个一维数组

  这一次没有直接给出一维数组的元素个数，可以动态的给出

• 举例

  int [ ] [ ] arr=new int [3] [ ]；

  arr [0]=new int [2]；

  arr [1]=new int [3]；

  arr [2]=new int [1]；

public class demo {
    public static void main(String[] args) {
        int[][]arr=new int[3][2];
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        arr[0]=new int[]{1,2};
        arr[1]=new int[]{3,4};
        arr[2]=new int[]{5,6};
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[2][0]);
        System.out.println(arr[2][1]);
    }
}

二维数组格式-3

二维数组格式

• 数据类型 [ ] [ ] 变量名=new 数据类型 [ ] [ ] {{元素…}，{元素…}，{元素…}…}；

• 简化版：

  数据类型[][] 变量名 = {{元素…},{元素…},{元素…}}；

• 这个格式属于静态初始化：由我们指定具体的元素值，由系统给分配长度

• 举例

  int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}；

  int[][] arr = {{1,2,3},{5,6},{7}}；

public class demo {
    //定义一个二维数组，打印每一个二维数组中的一维数组,再打印每一个二维数组中的元素
    public static void main(String[] args) {
        int[][]arr=new int[][]{{3,5,7,9},{2,4,6,8},{0,1}};
        System.out.println(arr[0]);
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);
        System.out.println(arr[0][3]);
        System.out.println(arr[1]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);
        System.out.println(arr[1][3]);
        System.out.println(arr[2]);
        System.out.println(arr[2][0]);
        System.out.println(arr[2][1]);
    }
}

二维数组-遍历

public class demo {
    public static void main(String[] args) {
        int[][]arr=new int[][]{{3,5,7,9},{2,4,6,8},{0,1,3,6}};
        //外循环控制的是二维数组的长度，其实就是一维数组的个数
        for (int i = 0; i < 3; i++) {
            //内循环控制的是一维数组的长度
            for (int j = 0; j < 4; j++) {
                //同行输出
                System.out.print(arr[i][j]);
            }
            //换行
            System.out.println();
        }
    }
}

二维数组-求和

public class demo {
    //年销售额求和
    public static void main(String[] args) {
        int[][]arr=new int[][]{{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        int n=0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 3; j++) {
                n+=arr[i][j];
            }
        }
        System.out.println(n);
    }
}

import java.util.Scanner;
public class demo {
    //杨辉三角
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数");
        int n = sc.nextInt();
        //让行数和列数一样
        int[][] arr = new int[n][n];
        //首尾设置为1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0] = 1;
            arr[i][i] = 1;
        }
        //补充数组内的数字
        for (int i = 2; i < n; i++) {
            for (int j = 1; j < n; j++) {
                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
            }
        }
        //打印三角形
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

public static void main(String[] args) {
       //思考参数传递问题
		int a = 10;
		int b = 20;
		System.out.println("a: " + a + ",b: " + b);
		change(a,b);
		System.out.println("a: " + a + ",b: " + b);

		int[] arr = {1,2,3,4,5};
		change(arr);
		System.out.println(arr[1]);
	}

	public static void change(int a,int b)  {

		System.out.println("a: " + a + ",b: " + b);
		a = b;
		b = a + b;
		System.out.println("a: " + a + ",b: " + b);
	}

	public static void change(int[] arr){
		for(int x = 0 ; x < arr.length ; x++){
			if(arr[x]%2 == 0){
				arr[x] *= 2;
			}
		}
	}

总结

• 在调用方法时，有时需要进行参数传递，有两种情况

  一种就是基本数据类型作为参数传递，属于值传递，就是把实参的值传过去，形参的改变不影响实参。

  一种就是引用类型作为参数传递，属于引用传递，传递的是地址值，形参的改变会影响实参。

递归

递归概述

**递归：**方法定义中调用方法本身的现象。

• 递归所体现的救赎一种拆分合并的思想

递归注意事项

• 要有出口，否则就是死递归（会造成栈溢出）
• 次数不能太多，否则就内存溢出

public class demo {
    public static void main(String[] args) {
    }
     //StackOverflowError 栈溢出
    private static void show(int num) {
        System.out.println("递归");
        num--;
        if(num>1){
            show(num);
        }else{
            return;
        }
    }
}

public class demo {
    public static void main(String[] args) {
        //OutOfMemoryError:Java heap space 堆溢出
        int[] ints = new int[900000000];
    }
}

public class demo {
    //用递归的方法求5的阶乘
    public static void main(String[] args) {
        int num=diGui(5);
        System.out.println(num);
    }
    
    private static int diGui(int i) {
         if(i==1){
             return 1;
         }else{
             return i*diGui(i-1);
         }
    }
}

不死神兔问题

斐波那契数列

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

public class demo{
    //兔子数列普通做法，定义一个数组
    public static void main(String[] args) {
        int[] arr=new int[20]; //arr[19]
        arr[0]=1;
        arr[1]=1;
        for (int i = 2; i < arr.length; i++) {
           // 从第三个数开始，后面的每一个数 = 他前面的两个数之和。
            arr[i]=arr[i-1]+arr[i-2];
        }
        System.out.println("兔子的对数："+arr[19]);
    }
}

public class demo {
    //递归方法输出兔子数列
    public static void main(String[] args) {
        int sum = sumRabbit(20);
        System.out.println(sum);
    }
    
    private static int sumRabbit(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return sumRabbit(n - 1) + sumRabbit(n - 2);
        }
    }
}

7-18笔记整理

面向对象

面向过程思想概述

• 面向过程开发其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求
• 面向过程的代表语言：C语言

面向对象思想概述

• 当需求单一或者简单时，我们一步步去操作没问题，并且效率也挺高
• 可随着需求的更改、功能的增多，发现需要每一个步骤很麻烦，这时就开始思考能不能把这些步骤和功能再进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起
• 这样结构就清晰了很多，用的时候找到对应的类就可以了。
• 这就是面对对象的思想

面对对象思想特点

• 是一种更符合我们思想习惯的思想 懒人思想

• 可以将复杂的时间简单化

• 将我们从执行者变成了指挥者

  角色发生了转换

面对对象思想举例

举例

洗衣服：换下衣服–盛水–浸泡–手搓–漂清–晾干

全自动洗衣机----一键洗衣、烘干

面向对象特征

• 封装（encapsulation）
• 继承（inheritance）
• 多态（polymorphism）

面向对象开发

就是不断的创建对象，适用对象，指挥对象做事情

类与对象概述

我们学习编程是为了什么

我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。

我们如何描述现实世界事物

• 举例：描述学生事物

  ​ 姓名、年龄、性别……

  ​ 学习、吃饭、睡觉……

  属性：就是该事物的描述信息

  行为：就是该事物能够做什么

  我们学习编程语言，就是为了模拟现实中的事物，我们学习java语言最基本的单位是类。所以，我们就应该把事物用一个类来体现。

  由此我们就得到了现实中的事物和类的对应关系

  事物 类

  属性-----------------成员变量

  行为-----------------成员方法

定义类其实就是定义类的成员（成员变量和成员方法）

• 成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外
• 成员方法 和以前定义方法是一样的，只不过把static去掉

类和对象的概念

• 类：就是一组相关的属性和行为的集合

• 对象：是该类事物的具体表现

• 举例

  类 学生

  对象 班长就是一个对象

学生类的定义

• 学生事物

  属性：姓名，年龄，地址……

  行为：吃饭，睡觉，上课……

• 学生事物与学生类的对应关系

  属性---------成员变量

  行为---------成员方法

public class Person {
    //学生类代码
    //成员变量：定义在类中方法外的变量。
    String name = "张三";
    int age = 23;
    char sex = '男';
    
    //成员方法：你以前怎么定义方法的，和以前一样，只是可以去掉static
    public void eat() {
        System.out.println("吃饭");
    }
    
    public void sleep() {
        System.out.println("睡觉");
    }
    
    public void talkLove(String name) {
        System.out.println("跟" + name + "谈恋爱 ");
    }
}

手机类的定义

public class Phone {
    // 定义成员变量
    String name="小米";
    String color="白色";
    double price=799;
    
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
    
    public void sendMsg(String name,String content) {
        System.out.println("给"+name+"发了短信:"+content);
    }
}

学生类的使用

• 文件名问题

  在一个java文件中写两个类：一个基本的类，一个测试类

  建议：文件名称和测试类名称一致

• 如何使用呢

  创建对象使用

• 如何创建对象呢

  格式：类名 对象名 = new 类名（）；

• 如何使用成员变量呢

  格式：对象名.变量名

• 如何使用成员方法呢

  格式：对象名.方法名（…）

public class MyTest {
    public static void main(String[] args) {
      //我们定义好了一个类，就是想要去使用这个类，那我们就创建一个测试类，提供一个主方法，作为入口,在主方法中取使用这个类。
      //类，本身是一个抽象的概念，你不能直接去使用。你必须要对类，进行实例化，实例化完毕之后，才能使用。
        //所谓实例化，就是创建该类的对象。然后使用该类的对象，去调用类中的属性和功能。
        //怎么来创建对象，可以借助一个关键字new 来完成类的实例化。
        //创建该类的对象的语法
        //类名 对象名=new 类名();
        Person p=new Person();
        //就可以通过对象名，来调用类中的属性和方法。
        //调用成员变量，获取成员变量的值。
        String mingzi= p.name;
        int age = p.age;
        char ch=p.sex;
        System.out.println("姓名："+mingzi);
        System.out.println("年龄：" + age);
        System.out.println("性别：" +ch);
        //调用成员方法
        p.eat();
        p.sleep();
        p.talkLove("刘亦菲");
        System.out.println("===================================");
        Person p2 = new Person();
        //设置成员变量的值
        p2.name="王祖贤";
        p2.age=17;
        p2.sex='女';
        System.out.println(p2.name);
        System.out.println(p2.age);
        System.out.println(p2.sex);
        p2.sleep();
        p2.eat();
        p2.talkLove("紫霞仙子");
    }
}

手机类的使用

public class MyTest {
    public static void main(String[] args) {
        //创建Phone类的对象
        Phone phone = new Phone();
        //获取成员变量的值
        String name = phone.name;
        String color = phone.color;
        double price = phone.price;
        System.out.println(name);
        System.out.println(color);
        System.out.println(price);
        phone.call("王祖贤");
        phone.sendMsg("林青霞","很想你");
        //一个类，可以创建他的很多对象。
        Phone phone1 = new Phone();
        phone1.name="魅族";
        phone1.color="黑色";
        phone1.price=8777;
        System.out.println(phone1.name);
        System.out.println(phone1.price);
        System.out.println(phone1.color);
        phone1.call("张曼玉");
        phone1.sendMsg("李丽珍","你好");
    }
}

一个对象的内存图

两个对象的内存图

三个对象的内存图

成员变量和局部变量的区别

在类中的位置不同

• 成员变量：在类中方法外
• 局部变量：在方法定义中或者方法声明上

在内存中的位置不同

• 成员变量：在堆内存
• 局部变量：在栈内存

生命周期不同

• 成员变量：随着对象的创建而存在，随着对象的消失而消失
• 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

• 成员变量：有默认初始值
• 局部变量：没有默认初始值，必须定义、赋值，然后才能使用

注意事项：

• 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
• 先在方法内部这个局部范围找这个变量，找到就使用，没有找到，就去成员范围找，找到就使用，没有找到，就报错

方法的形式参数是类名的时候如何调用

Java中参数传递问题

• 形式参数

  基本类型：形式参数的改变不影响实际参数

  引用类型：形式参数的改变直接影响实际参数

• 方法的参数是类名

  如果你看到了一个方法的形式参数是一个类类型（引用类型），这里其实需要的是该类的对象

//可以将多个类，并列的定义到一个.java文件中。public 只能加给其中作为入口的那个类
//但是建议一个类，就是一个.java 文件
public class MyTest {
    public static void main(String[] args) {
        //作业：自己画一下内存图。
        int num = 10;
        //当你以后看到一个方法的形参，要一个类 类型，你就传递一个该类的对象。
        //基本类型作为参数传递，属于值传递。形参的改变，不影响实参。
        //引用类型作为参数传递，属于引用传递，传递的是地址值，形参的会影响实参。
        Student student = new Student();
        System.out.println("new 的对象"+ student);
        test(student, num);
        System.out.println(num); //10
        System.out.println(student.num);//30
    }
    
    public static void test(Student s, int num) {
        System.out.println("方法形参收的那个对象"+s);
        num += 20;
        s.num = num;
    }
}

class Student {
    int num = 120;
}

匿名对象的概述和应用

什么是匿名对象

• 就是没有名字的对象

匿名对象应用场景

• 调用方法：仅仅只调用一次的时候
• 匿名对象可以作为实际参数传递

public class MyTest {
    public static void main(String[] args) {
        //匿名对象，没有名字对象。
        //匿名对象可以直接调用属性和功能。
        int num = new Dog().num;
        System.out.println(num);
        System.out.println("=====================");
        //同一个对象，调用了eat()方法两次
        Dog dog = new Dog();
        dog.eat();
        dog.eat();
        System.out.println("========================");
        //两个匿名对象，各调用了一次。
        new Dog().eat();
        new Dog().eat();
        System.out.println("=============================");
        //1.当你只想要调用一次的时候，就可以使用匿名对象来调用。
        //2.匿名对象可以作为参数传递。
        //当你以后看到一个方法的形参，要一个 类 类型，你就传一个该类对象。
        Dog dog1 = new Dog();
        test(dog1, 20);
        //匿名对象，作为参数传递
        test(new Dog(), 120);
        System.out.println(dog1.num); //20
        System.out.println(new Dog().num);//100
    }
    
    public static void test(Dog dog, int num) {
        dog.num = num;
        //System.out.println(dog.num);
    }
}

class Dog {
    int num = 100;
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

封装

封装的概述

封装的概述

• 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

封装的好处

• 隐藏实现细节，提供公共的访问方式
• 提高了代码的复用性
• 提高安全性

封装的原则

• 将不需要对外提供的内容都隐藏起来
• 把属性隐藏，提供公共方法对其访问

private关键字的概述和特点

private关键字特点

• 是一个权限修饰符
• 可以修饰成员变量和成员方法
• 被其修饰成员变量和成员方法
• 被其修饰的成员只能在本类中被访问

private应用的标准案例

private最常见的应用

• 把成员变量用private修饰
• 提供对应的getXxx（）和setXxx（）的方法

例一

public class Student {
    //以后我们在定义一个类时，会把成员变量私有掉，然后提供公共的set get 方法，让外界通过set get方法间接的去给成员变量设置值，以及获取成员变量的的值
    private String name;
    //private 私有的 权限修饰符，可以修饰成员变量，也可以修饰成员方法，被修饰的成员，只能在本类中访问，外界无法直接访问。
    private int age;
    //我们提供公共的 设置和获取的方法，让外界通过调用方法来给成员变量设置值和获取值。
    public void setAge(int nl){
        if(nl>=0&&nl<=100){
            age = nl;
        }
    }
    public void setName(String mz){
        name=mz;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public void show() {
        System.out.println("姓名：" + name + "===年龄：" + age);
    }
}

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        //student.name="张三";
        //我们采用 对象名.成员变量名=值 这种方式给成员变量设置值的方式，他不能排除一些不合理的数据。
        //我们可以采用一种手段，来屏蔽掉 对象名.成员变量名=值 这种设置值的方式。
        //student.age=200;

        //System.out.println(student.name);
        //System.out.println(student.age);

        student.setName("张三");
        student.setAge(100);

        String name = student.getName();
        int age = student.getAge();

        System.out.println(name);
        System.out.println(age);
        student.show();
    }
}

例二

public class Phone {
    //private 权限修饰符，私有的 可以修饰 成员变量，成员方法，被修饰后的成员，只能在本类中访问，外界无法直接访问。
    private String name;
    private String color;
    private double price;

    //setName 命名规范
    public void setName(String mingzi) {
        name = mingzi;
    }

    public void setColor(String yanse) {
        color = yanse;
    }

    public void setPrice(double jiage) {
        price=jiage;
    }
    //getName 命名规范
    public String getName(){
        return name;
    }

    public String getColor() {
        return color;
    }

    public double getPrice() {
        return price;
    }
    //权限修饰符 状态修饰符 返回值类型 方法名（形参列表）{方法体}
    //public 权限修饰符公共的，可以修饰类，成员变量。成员方法 范围最大，在任何地方都能够访问到
    private void call(){
        System.out.println("打电话");
    }
}

public class MyTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        //调用set方法给成员变量设置值。
        phone.setName("小米");
        phone.setColor("黑色");
        phone.setPrice(799);

        String name = phone.getName();
        String color = phone.getColor();
        double price = phone.getPrice();
        //对于有返回值的方法，可以输出调用。
        //System.out.println(phone.getName());
        System.out.println(name);
        System.out.println(color);
        System.out.println(price);

       // phone.call(); //私有方法 ，外界无法调用。
        Dog dog=new Dog();
        String name1 = dog.name;
        //int age=dog.age;
       //char sex= dog.sex;
        dog.test();
    }
}

例三

public class Dog { //缺省的
    //权限修饰符 所代表的的范围如下 由大到小，
    //public > protected>缺省的>private
    public String name;
    int age;
    protected char sex;
    private int hight;

    public void test() {
    }

    protected void haha() {
    }

    void hehe() {
    }

    private void show() {
    }
}

public class MyTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        int age = dog.age;
        String name = dog.name;
        char sex = dog.sex;
    }
}

this关键字的概述和应用

为什么要有this

• 当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题

this关键字特点

• 是当前类的对象引用。
• 简单地讲，它代表当前类的一个对象。谁调用这个方法，那么该方法的内部的this就代表谁

this的应用场景

• 解决局部变量隐藏成员变量

public class Cat {
    private String name;
    private int age;

    //this 代表该类的一个引用，你可以理解就是该类的对象 ，哪个对象调用这个方法，方法中的this就代表那个对象。
    public void setName(String name){
        System.out.println("方法中this代表的那个对象："+this);
        this.name=name;
    }

    public void setAge(int age) {
        System.out.println("方法中this代表的那个对象：" + this);
        this.age= age;
    }

    public void show(){
        System.out.println("姓名: "+this.name+" 年龄: "+this.age);
    }
}

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println("外键创建的："+cat);
        cat.setName("大脸猫");
        cat.setAge(20);
        cat.show();

        //当我调用set方法时 形参的名称和成员变量的名称重名了，发现把成员变量就致盲了。
        //我们想要区分出来成员变量和局部变量。我们可以使用一个关键字this来区分。
        //你始终记着，方法中的this，代表那个调用者。

        Cat cat2 = new Cat();
        System.out.println("外键创建的222：" + cat2);
        cat2.setName("大脸猫2222");
        cat2.setAge(200);
        cat2.show();
    }
}

快速生产get set方法

public class Teacher {
    private String name;
    private int age;
    //快速生成get set 方法 按 alt+insert 弹出菜单，选getter And Setter

    public String getName() {
        return this.name;
    }

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

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

完