类和对象（二）

• 面向对象基础
• 方法基础用法

第一章 面向对象基础

第01节 思想概述

什么是面向对象？

面向过程：所有的事情，都是自己做。（亲力亲为）

面向对象：找人帮你做事情，请的人叫做对象，对象具备有做事情的功能。（请人做事）

生活实例：

张三，游戏代练。

李四玩王者荣耀，想要上王者，自己菜，需要请人帮我做事情，找代练。提供材料，帮我上王者。

张三，就是对象，他具备有上王者的功能。

怎么对象法呢？如何去模拟现实生活

上述图片当中

设计图纸相当于是一个 java类，注意他只需要一份即可。但是不能实际做操作。

右侧的具体宝马Mini就是实实在在的事物，他也就是我们java当中的对象，注意他是由设计图纸java类产生的，对象来自于类。

如果我们想要去描述一个类，应该如何描述呢？

我们可以对图纸类，进行描述，通过两方面进行描述。

1. 他有什么？

   长、宽、高、颜色、价格、名称 …

2. 他可以干什么？

   跑、参加车友会、看小姐姐…

小结

现实世界	Java世界
车辆设计图纸	Java类 class Car{ … }
具体的车辆 Mini	Java对象 Car miniOne = new Car( );
Mini的属性信息	成员变量（类中方法外的变量） int price; String color;
Mini的行为信息	成员方法（不写static的方法） 跑、参加车友会、看小姐姐…

第02节 快速入门

类的定义

/**
 * 汽车类【类的定义】
 * 1. 成员变量： 写在类当中,方法外的变量
 * 2. 成员方法： 昨天的方法去掉 static 关键字
 */
public class Car {

    //成员变量（有什么属性）
    String brand;
    int price;
    String color;

    //成员方法（有什么行为）
    public void run(){
        System.out.println("汽车跑...");
    }
}

类的使用

/***
 * 测试类【类的使用】
 * 创建对象，调用成员（成员变量或者成员方法）
 */
public class Test {

    public static void main(String[] args) {

        //创建对象
        //格式: 类名称 对象名称 = new 类名称();
        Car one = new Car();

        //调用成员 成员变量
        one.brand = "宝马mini";
        one.price = 35;

        //打印输出
        System.out.println(one.brand); //宝马mini
        System.out.println(one.price); //35
        System.out.println(one.color); //null

        //调用成员 成员方法
        one.run();  //汽车跑...
    }
}

第03节 内存图

1、一个对象的内存图

2、两个对象内存图

3、两个对象指向相同堆内存

第04节 两种变量

理论说明

1. 成员变量：
	A. 代码位置来讲: 写在类当中，方法外的变量。
	B. 内存位置来讲: 存在于堆内存当中。 
		因为内存位置不同，所以具备特点:
		a. 堆内存的变量, 有默认值
		b. 堆内存的变量, 生命周期长
		c. 堆内存的变量, 对象在，成员在，对象亡，成员亡。
	
2. 局部变量：
	A. 代码位置来讲: 写在方法当中的变量
	B. 内存位置来讲: 存在于栈当中
		因为内存位置不同，所以具备特点：
		a. 栈内存的变量，没有默认值
		b. 栈内存的变量，生命周期短
		c. 栈内存的变量，方法在，局部在，方法亡，局部亡。

案例代码

狗类

//狗类
public class Dog {

    String name = "旺财";
    int age = 3;

    //定义成员方法
    public void lookDoor(String who){
        System.out.println("汪汪汪..."+who);
    }

    public void swim(){
        String s = "狗刨";
        System.out.println(s);
    }

    public void show(){
        String name = "雷恩加尔";
        System.out.println(name);  //雷恩加尔
        //问题: 如果我想要展示旺财，怎么办?
        //this. 的都是成员
        System.out.println(this.name); //旺财
    }
}

测试类

public class Test {

    public static void main(String[] args) {

        //创建对象
        Dog d = new Dog();

        //调用成员
        System.out.println(d.name);  //旺财
        System.out.println(d.age);   //3

        d.lookDoor("老王");   //汪汪汪...老王
        d.swim();   //狗刨

        System.out.println("------");

        //调用方法
        d.show();  //旺财还是雷恩加尔? 雷恩加尔  就近原则
        //谁离我近，我就优先使用谁。

    }
}

第二章 方法基础用法

第01节 前景回顾

为什么使用方法？

为了提高代码的复用性。
我们将重复的代码，写到方法当中，可以做到编写一次代码，到处调用的效果。重复的代码只需要编写一次。

方法的定义格式？

重点掌握定义格式当中的三要素：

1. 返回值类型: 方法执行完毕之后，得到的结果，这个结果的数据类型，就是返回值类型。
2. 参数列表：方法执行之前，需要的数据信息，可能是需要多个，也可以是不需要。
3. 方法名称: 命名规范，小驼峰命名。第一个单词首字母小写，其他单词首字母大写。 method()  getMaxValue()

第02节 基础练习

第01题

需求：
	定义一个方法，用于比较两个数据的大小，获取到较小值。
	
思考: 三要素
	1. 返回值类型   较小值 int
	2. 参数列表	    需要两个参数  int,int
	3. 方法名称     尽量的"见名知意"  getMin

代码

//定义一个方法，用于比较两个数据的大小，获取到较小值。
public class Test01 {

    public static void main(String[] args) {
        //这里的x和y 在传入方法的时候，我们叫做实际参数，简称"实参"
        int x = 5;
        int y = 6;
        //调用方法
        int min = getMin(x, y);
        System.out.println("min = " + min);
        //调用方法
        int min1 = getMin(12, 15);
        System.out.println("min1 = " + min1);
        //调用方法
        int min2 = getMin(x, 7);
        System.out.println("min2 = " + min2);
        int min3 = getMin(88, 'A');
        System.out.println("min3 = " + min3);
    }

    //这里的 int a,int b 叫做形式参数，简称 "形参"
    public static int getMin(int a,int b){
        int min = a<b?a:b;
        return min;
    }
}

第02题

需求:
	定义一个方法，返回统计水仙花数的个数。（水仙花数，默认为三位数）

思考: 三要素
	1. 返回值类型： int 个数
	2. 参数列表:   不需要的
	3. 方法名称:   waterFlower

代码

//定义一个方法，返回统计水仙花数的个数。（水仙花数，默认为三位数）
public class Test02 {

    public static void main(String[] args) {
        int i = waterFlower();
        System.out.println("i = " + i);
    }

    public static int waterFlower(){
        int count = 0;
        for (int i = 100; i < 1000; i++) {
            //求出个位十位百位数字
            int bai = i/100%10;
            int shi = i/10%10;
            int ge = i%10;
            //判断水仙花
            if (bai*bai*bai + shi*shi*shi + ge*ge*ge == i){
                count++;
            }
        }
        return count;
    }
}

第03题

需求:
	定义一个方法，打印输出一个x行y列的长方形。

思考: 三要素
	1. 返回值类型： 无 void
	2. 参数列表:   int,int
	3. 方法名称:   pintRectangle

代码

//定义一个方法，打印输出一个x行y列的长方形。
public class Test03 {

    public static void main(String[] args) {

        //调用方法
        printRectangle(3,5);

    }

    public static void printRectangle(int x,int y){
        //外层for循环控制行数
        for (int i = 0; i < x; i++) {
            //内层for循环控制列数
            for (int j = 0; j < y; j++) {
                System.out.print("*");
            }
            //两个for循环中间换行
            System.out.println();
        }
    }
}

第03节 参数传递

情况一：基本数据类型作为形参

案例代码

//目标：基本数据类型作为方法的形式参数
public class Test01 {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a = " + a);  //a = 10
        System.out.println("b = " + b);  //b = 20
        change(a,b);
        System.out.println("a = " + a);  //a = 10
        System.out.println("b = " + b);  //b = 20
    }

    //基本数据类型 int,int 作为方法的形式参数 （形参）
    public static void change(int x,int y){
        x += 100;
        y += 100;
    }
}

效果图

小结：如果方法的参数是基本数据类型，那么形式参数在方法当中的变化，不会影响实际参数。

情况二：引用数据类型作为形参

案例代码

//目标：引用数据类型作为方法的形式参数
public class Test02 {

    public static void main(String[] args) {
        int[] array = {
                11,22,33
        };
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        change(array);
        System.out.println("----------");
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    //引用数据类型 int[] 作为方法的形式参数 （形参）
    public static void change(int[] array){
        array[0] += 100;
        array[2] += 100;
    }
}

效果图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DUSOtXj5-1626779545527)(%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0Day07.assets/image-20210720155215537.png)]

小结：如果方法的参数是引用数据类型，形参在方法当中的变化，会影响到实参

第04节 方法重载

引入案例

需求:
	计算两个数据相加的和、计算三个数据相加的和、计算四个数据相加的和。

代码

//计算两个数据相加的和、计算三个数据相加的和、计算四个数据相加的和。
public class Test01 {

    public static void main(String[] args) {
        //调用方法
        int sumTwo = getSum(10, 20);
        System.out.println("sumTwo = " + sumTwo);
        int sumFour = getSum(10, 20, 30, 40);
        System.out.println("sumFour = " + sumFour);
    }

    //两个数据求和
    public static int getSum(int a,int b){
        int result = a + b;
        return result;
    }

    //三个数据求和
    public static int getSum(int a,int b,int c){
        int result = a + b + c;
        return result;
    }

    //四个数据求和
    public static int getSum(int a,int b,int c,int d){
        int result = a + b + c + d;
        return result;
    }
}

发现问题

我们发现，可以在一个类当中，定义多个同名字的方法。

小结：

什么是方法重载呢？

同一个类当中，出现了同名方法，参数不同的情况，我们叫做方法重载。（同一个类、同名方法、参数不同）

方法重载的好处？

减少方法命名的次数。因为参数不相同，JVM虚拟机可以根据参数去识别具体是哪一个方法

第05节 可变参数

引入

上述案例当中，我们计算了 2个数据的和、3个数据的和、4个数据的和。
如果想要计算 N 个数据的和应该怎么办呢?

可以采用可变参数去完成。

案例

//可变参数快速入门
public class Test01 {

    public static void main(String[] args) {
        //方法调用
        int sum = getSum(10, 20, 30);
        System.out.println("sum = " + sum);

        int sum1 = getSum(10, 20, 30, 40);
        System.out.println("sum1 = " + sum1);
    }

    //定义方法，采用可变参数
    //如果我们编写的是 三个点，自动变成可变参数，可以传递N个数据来，本质就是数组
    public static int getSum(int... array){
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum;
    }
}

注意事项

1. 可变参数，在一个方法当中，只能出现1个
2. 可变参数，必须放在方法参数的最后面