1、昨日复习

面向对象思想编程内容的三条主线分别是什么
①类及类的成员：属性、方法、构造器；代码块、内部类
②面向对象的三大特征：封装、继承、多态
③其它关键字：this,super,abstract,interface,static,final,package,import

面向对象的编程思想？
（类、对象；面向对象的三大特征；。。。）
2. 谈谈你对面向对象中类和对象的理解，并指出二者的关系?
类：抽象的、概念上的内容
对象：实实在在存在的一个个体。
对象是由类派生出来的。
3. 面向对象思想的体现一：类和对象的创建和执行操作有哪三步？
①创建类
②类的实例化
③调用对象的结构：”对象.属性” “对象.方法”
4. 画出如下代码在执行时的内存分配情况
class Car{
String color = “red”;
int num = 4;
void show(){
int a = 10;
System.out.println(“color=”+color+”,num=”+num);
}
}
class CarTest {
public static void main(String[] args) {
Car c1 = new Car();
Car c2 = new Car();
c1.color = “blue”;
c1.show();
c2.show();
} }

类的方法内是否可以定义变量？是否可以调用属性？是否可以定义方法？是否可以调用方法？
是；是；否；是

JVM内存结构
编译完源程序以后，生成一个或多个字节码文件。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
《JVM规范》
虚拟机栈，即为平时提到的结构，我们将局部变量存储在栈结构中
堆，我们将new出来的结构（比如：数组、对象）加载在堆空间中，补充：对象的属性（非static）加载在堆空间中。
方法区：类的加载信息、常量池、静态域。
QQ截图20211210143351.png

2、理解“万事万物皆对象”

1.JAVA语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
2.涉及到java语言与前端HTML、后端的数据库交互时，前后端的结构在java层面交互时，都体现为类、对象。

3、匿名对象的使用

没有定义对象名 new 类名().show(); 可以调用类的属性和方法。
开发中如何使用匿名对象？

4、再谈方法

4.1 方法的重载

重载的概念：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。（两同一不同：同一类、相同方法名；参数列表不同）
跟方法的权限修饰符、返回值类型、形参变量、方法体都没有关系！
重载的特点︰
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

package com.atguigu.java;
/*
 * 2.编写程序，定义三个重载方法并调用。方法名为mOL。 三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别
执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的main ()方法中分别用参数区别调用三个方法。
3.定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方
法求两个double值中的最大值，第三个方法求三个double值中的最大值，
并分别调用三个方法。
 */
public class Exerr1 {
    public static void main(String[] args) {
        Method m = new Method();
        m.mOL(5);
        m.mOL(8, 5);
        m.mOL("我去吃饭了!!!");
        System.out.println(m.getMax(5, 9));
        System.out.println(m.getMax(5.7, 5.2, 9.6));
    }
}
class Method {
    public void mOL(int a) {
        System.out.println(a * a);
    }
    public void mOL(int a, int b) {
        System.out.println(a * b);
    }
    public void mOL(String s) {
        System.out.println(s);
    }
    public int getMax(int a, int b) {
        return a > b ? a : b;
    }
    public double getMax(double a, double b) {
        return a > b ? a : b;
    }
    public double getMax(double a, double b, double c) {
        return (a > b ? a : b) > c ? (a > b ? a : b) : c;
    }
}

4.2 可变形参的方法

QQ截图20211210163909.png
1.具体使用：
1.1声明格式：方法名(参数的类型名 …参数名)
1.2可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
1.3可变个数形参的方法与同名的方法之间，彼此构成重载
1.4可变参数方法的使用与方法参数部分使用数组是一致的
1.5方法的参数部分有可变形参，需要放在形参声明的最后
1.6在一个方法的形参位置，最多只能声明一个可变个数形参
注意：可变形参和同一类型的数组不构成重载

4.3 方法参数的值传递机制

关于变量的赋值：
如果是基本数据类型，此时赋值的是变量所保存的数据值。
如果是引用数据类型，此时赋值的是变量所保存的数据的地址值。
形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值
形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
QQ截图20211211165344.png

4.4 递归方法

递归方法：一个方法体内调用它自身。
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

package com.atguigu.java;
public class Practice3 {
    public static void main(String[] args) {
        // 已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0的整数，求f(10)的值。
        Practice3 p = new Practice3();
        // p.f(0);
        System.out.println(p.f(10));
    }
    public int f(int n) {
        if (n == 0) {
            return 1;
        } else if (n == 1) {
            return 4;
        } else if (n > 1) {
            return f(n - 2) + 2 * f(n - 1);
        } else {
            System.out.println("n的范围有误！！！");
            return -1;
        }
    }
}

package com.atguigu.java;
public class Practice4 {
    public static void main(String[] args) {
        // 已知一个数列：f(20) = 1,f(21) = 4,f(n+2) =
        // 2*f(n+1)+f(n),其中n是大于0的整数，求f(10)的值。
        Practice4 p = new Practice4();
        // p.f(22);
        System.out.println(p.f(10));
    }
    public int f(int n) {
        if (n == 20) {
            return 1;
        } else if (n == 21) {
            return 4;
        } else {
            return f(n + 2) - 2 * f(n + 1);
        }
    }
}

package com.atguigu.java;
/*
 * 输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
    1 1 2 3 5 8 13 21 34 55
    规律：一个数等于前两个数之和
    要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来
 */
public class Practice5 {
    public static void main(String[] args) {
        Practice5 p = new Practice5();
        p.method(10);
    }
    public void method(int n){
        for(int i=1;i<=n;i++){
            System.out.print(f(i)+"\t");
        }
    }
    public int f(int n) {
        if (n == 1) {
            // System.out.print(1 + "\t");
            return 1;
        } else if (n == 2) {
            // System.out.print(1 + "\t");
            // f(n-1);
            return 1;
        } else if (n > 2) {
            // System.out.println(f(n-1)+f(n-2));
            return f(n - 1) + f(n - 2);
        } else {
            System.out.println("超出范围");
            return -1;
        }
    }
}

Java 学习知识库

Day09