面向对象（20201219~20201225）

学习面向对象内容的三条主线（第4-6章）

1.Java类及类的成员：属性、方法、构造器;代码块、内部类
2.面向对象的三大特征：封装性、继承性、多态性（抽象性）
3.其他关键字：this、super、static、final、abstract、interface、package、import

面向过程与面向对象的概述

面向对象的两个要素：类&对象

类：对一切事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例（instance）

面向对象程序设计的重点是类的设计。
设计类，就是设计类的成员。

package com.atguigu.java;
/*一、设计类：其实就是设计类的成员
*

属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类
二、类和对象的使用（面向对象思想落地的实现）
1.创建类：设计类的成员
2.创建类的对象
3.通过“对象.属性”或“对象.方法”调用对象的结构
三、如果创建了一个类的多个对象，则每个对象的都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

四、对象的内存解析
*/
public class OOP {
public static void main(String[] args) {

//创建Person类的对象
Person p1=new Person();//调用对象的结构：属性、方法
//调用属性:“对象.属性”
p1.name="tom";
p1.isMale = true;//调用方法：“对象.方法”
p1.eat();
p1.sleep();
p1.talk("English");//****************************
Person p2=new Person();//每new一次堆空间都会重新开劈一块内存
System.out.println(p2.name);//null
System.out.println(p2.isMale);//false//****************************
//将p1变量保存的对象地址值赋给p3，导致p1和p3指向了堆空间中的同一个对象实体
Person p3=p1;
System.out.println(p3.name);//tomp3.age=10;
System.out.println(p1.age);//10

}
}
class Person{

//属性
String name;
int age=1;
boolean isMale;

//方法
public void eat() {
System.out.println(“吃饭”);
}

public void sleep() {
System.out.println("睡觉 ");
}

public void talk(String language) {
System.out.println(“讲话，使用的是：”+language);
}

}

对象的创建和使用：内存解析

区分成员变量与局部变量

方法里的变量都是局部变量

package com.atguigu.java;
/*

类中属性的使用
属性（成员变量）vs 局部变量
1.相同点

1.1定义变量的格式：数据类型 变量名=变量值

```
1.2先声明后使用
```
```
1.3变量都有其对应的作用域
```
2.不同点
```
2.1在在类中声明的位置不同
```

属性：直接定义在类的一对{}内

局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

```
2.2关于权限修饰符的不同
```

属性：可以在声明属性时，指明其权限，使用权限修饰符。

    常用的权限修饰符：private、public、缺省、protected--->封装性

    目前，大家声明属性时，都使用缺省就可以了

局部变量：不可以使用权限修饰符

```
2.3默认初始化值的情况
```

属性：类的属性，根据其类型，都有默认初始化值。

```
    整型(byte\short\int\long)：0
```
```
    浮点型(float\double)：0.0
```
```
    字符型char:0或'\u0000'
```
```
    布尔型(boolean):false
```

    引用数据类型(类如:String、数组、接口):null

局部变量：没有默认初始化值。

    意味着，我们在调用局部变量之前，一定要显式赋值

    特别地：形参在调用时，我们赋值即可

```
2.4在内存中加载的位置：
```

属性：加载到堆空间中（非static）

```
局部变量：加载到栈空间
```
*/
public class UserTest {
public static void main(String[] args) {
User u1=new User();
System.out.println(u1.name);//null
System.out.println(u1.age);//0
System.out.println(u1.isMale);//false
```
u1.talk("日语");
```
}
}
class User{
//属性（或者成员变量）
String name;
int age;
boolean isMale;

public void talk(String language) {//language：形参，也是局部变量
System.out.println(“我们使用”+language+“进行交流”);
}

public void eat() {
String food=“大饼”;//局部变量
System.out.println(“北方人喜欢吃：”+food);
}
}

方法

package com.atguigu.java;
/*

类中的方法的声明和使用
方法：描述类应该具有的功能。
比如：Math类：sqrt()\random()\
```
Scanner类:nextXxx()...
```

Arrays类：对数组进行排序sort()\用二分法查找某个值得位置：binarySearch()\输出数组的值：toString()\比较两个数组是否相同：equals()\

1.举例
void 无返回值，其他的都有相应的返回值
public void eat() {}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation) {}
2.方法的声明：权限修饰符返回值类型方法名(形参列表（可选且可多于1个）){
```
                   方法体
```
```
        }
```
注意：static、final、abstract来修饰的方法、后面再讲
3.说明：
```
3.1权限修饰符：
```

    Java规定的4种权限修饰符：private、public、缺省、protected--->封装性在细说

3.2返回值类型：有返回值 vs 没有返回值

    3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，

        需要使用return关键字来返回指定类型的变量或常量。

    3.2.2如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，

        就不需要使用return，但是如果使用的话，只能“return;”，表示结束此方法。

    3.2.3我们定义方法该不该有返回值？

```
        1.题目要求
```

        2.凭经验：具体问题具体分析

3.3方法名：属于标识符，遵循标识符等的规则和规范，“见名知意”，命名规则（驼峰法）：xxxYyyZzz

3.4形参列表：方法可以声明0个、1个或多个形参。（形参不可以定义值）

    3.4.1格式：数据类型1 形参1，数据类型2 形参2

    3.4.2我们定义方法该不该定义形参？

```
        1.题目要求
```

        2.凭经验：具体问题具体分析

```
3.5方法体：方法功能的体现
```
4.return关键字的使用：

    4.1使用范围：使用在方法体中

```
    4.2作用:a.结束方法
```

          b.针对于有返回值类型的方法，使用“return 数据”方式，结束方法且返回所要的数据。

    4.3注意点：return关键字后不可以声明执行语句。

5.方法的使用中：可以调用当前类的属性或方法

5.1特殊的：方法A中又调用了方法A：递归方法

```
5.2方法中不可以定义方法
```

*/
public class CustomerTest {
public static void main(String[] args) {
Customer cust1= new Customer();

   cust1.sleep(4);cust1.getNation("china");
}

}
//客户类
class Customer{
//属性
String name;
int age;
boolean isMale;

//方法
public void eat() {System.out.println("吃了");return;//return后不能声明表达式//System.out.println("报错");return后会报错
}public void sleep(int hour) {System.out.println("睡了"+hour+"小时");eat();//调用发放
}public String getName() {return name;
}public String getNation(String nation) {String info="我的国籍是："+ nation;System.out.println(info);return info;
}

}

public class Test {
public static void main(String[] args) {
Student stu=new Student();
stu.say(“张三”, “三年级”, “打球”,12);

}
class Student{
String name,major,interests;
int age;

public String say(String student_name,String student_major,String student_interests,int student_age) {String info=student_name+student_major+student_interests+student_age;System.out.println(info);return info;
}

练习1：
package com.atguigu.contain;
public class Test {
public static void main(String[] args) {

   PersonTese per1=new PersonTese();per1.name="tom";per1.age=10;per1.sex=1;per1.study();per1.showAge();int newage=per1.addAge(18);System.out.println(newage);PersonTese per2=new PersonTese();per2.showAge();//0
}

}

class PersonTese {
String name;
int age,sex;

public void study(){System.out.println("Studying");
}public void showAge() {System.out.println("age"+age);
}public int addAge(int i) {age +=i;return age;
}

}

练习2
public class Test {
public static void main(String[] args) {
Circle cir=new Circle();

   cir.radius=2.1;double area = cir.getArea();System.out.println(area);cir.getArea1();
}

}
class Circle{
double radius;

//求圆的面积
//方法一：
public double getArea(){double area =3.14*radius*radius;return area;
}//方法二：public void getArea1(){double area =3.14*radius*radius;System.out.println(area);
}

}

3.1
public class Test {
public static void main(String[] args) {

   Test  test=new Test();test.method();}public void method() {for (int i = 1; i <= 10; i++) {for(int j=1;j<=8;j++) {System.out.print("*");}System.out.println();
}

}
}
3.2
public class Test {
public static void main(String[] args) {

   Test test=new Test();//3.2测试//方式一：int area=test.method();System.out.println(area);//方式二：System.out.println(test.method());
}public int method() {for (int i = 1; i <= 10; i++) {for(int j=1;j<=8;j++) {System.out.print("*");}System.out.println();
}return 10*8;

}
}

3.3
public class Test {
public static void main(String[] args) {

   Test test=new Test();//3.2测试//方式一：int area=test.method(3,4);System.out.println(area);//方式二：System.out.println(test.method(5,6));
}public int method(int m,int n) {for (int i = 1; i <= m; i++) {for(int j=1;j<=n;j++) {System.out.print("*");}System.out.println();
}return m*n;

}
}

注意点：Cannot assign field “number” because “stu[i]” is null
解决方式：循环中未写stu[i]=new Student[];

192集
想不通看200集的内存解析

第四题解法一：public class Test { private static final Object[] Student = null; public static void main(String[] args) { //声明Student类型的数组 //String[] arr=new String[10]; //此时定义了stu是指向20个连续空间，空间中的值是引用类型数据(Student类型)，所以默认值为null。后续要给每个空间new一个对象，new完对象，给里面的属性赋值 //需要new 20个Student类型的对象，就可以按下方格式写，动态初始化 Student[] stu=new Student[20]; for(int i=0;i<stu.length;i++) { //错误点1：stu[i]表示的是地址值 //stu[i]=i+1; //给数组元素赋值 //new出来的Student不是数组，只是一个实例化对象，而数组存放的地址值指向这个对象 //new出来的是个对象，这个对象最为这个数组的一个元素 stu[i]=new Student(); //给Student对象的属性赋值 //学号1-20 stu[i].number=i+1; //1-6年级[1,7) stu[i].state=(int)(Math.random()6+1); //0-100分[0,101) stu[i].score=(int)(Math.random()101); } //遍历数组方法一： for(int i=0;i<stu.length;i++) { //System.out.println(stu[i]);//输出的外层数组结果是地址值哦 System.out.println(“学号是：”+stu[i].number+"，成绩是："+stu[i].score+"，年级是："+stu[i].state); } System.out.println("*******************"); //遍历数组方法二： for(int i=0;i<stu.length;i++) { String info=stu[i].info(); System.out.println(info); } System.out.println("*******************"); //问题一：打印出3年级的学生信息 for(int i=0;i<stu.length;i++) { if(stu[i].state3) { System.out.println(stu[i].info()); } } System.out.println("*********************"); //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息 for(int i=0;i<stu.length-1;i++) { for(int j=0;j<stu.length-i-1;j++) { if(stu[j].score>stu[j+1].score) { //如果需要换序，交换的是数组的元素：Student对象！！！ Student temp= stu[j]; stu[j]=stu[j+1]; stu[j+1]=temp; } } } for(int i=0;i<stu.length;i++) { String info=stu[i].info(); System.out.println(info); } }}class Student{ int number;//学号 int state;//年级 int score;//成绩 //遍历数组方法二： public String info() { return “学号是：”+number+"，成绩是："+score+"，年级是："+state; } }解法二：改进解法一，将操作数组的功能封装在方法中public class Test { private static final Object[] Student = null; public static void main(String[] args) { //声明Student类型的数组 //String[] arr=new String[10]; //此时定义了stu是指向20个连续空间，空间中的值是引用类型数据(Student类型)，所以默认值为null。后续要给每个空间new一个对象，new完对象，给里面的属性赋值 //需要new 20个Student类型的对象，就可以按下方格式写，动态初始化 Student[] stu=new Student[20]; for(int i=0;i<stu.length;i++) { //错误点1：stu[i]表示的是地址值 //stu[i]=i+1; //给数组元素赋值 //new出来的Student不是数组，只是一个实例化对象，而数组存放的地址值指向这个对象 //new出来的是个对象，这个对象最为这个数组的一个元素 stu[i]=new Student(); //给Student对象的属性赋值 //学号1-20 stu[i].number=i+1; //1-6年级[1,7) stu[i].state=(int)(Math.random()6+1); //0-100分[0,101) stu[i].score=(int)(Math.random()101); } //遍历数组 Test test=new Test(); test.print(stu); System.out.println("*******************"); //问题一：打印出3年级的学生信息 test.searchState(stu, 3); System.out.println("*******************"); //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息 test.sort(stu); //遍历数组 test.print(stu); } / * * @Description 遍历Student[]数组的操作 * @author yanlin_zhu * @version date 2020年12月20日下午8:29:53 * @param stu / public void print(Student[] stu) { for(int i=0;i<stu.length;i++) { String info=stu[i].info(); System.out.println(info); } } / * * @Description 查找Student数组中指定年级的学生信息 * @author yanlin_zhu * @version *date 2020年12月20日下午8:27:01 * @param stu 要查找的数组 * @param state 要找的年级 */ //查找指定学生年级，并输出该学生信息 public void searchState(Student[] stu,int state) { for(int i=0;i<stu.length;i++) { if(stu[i].statestate) { System.out.println(stu[i].info()); } } } / * * @Description 给student数组排序 * @author yanlin_zhu * @version *date 2020年12月20日下午8:29:12 * @param stu 要排序的数组 */ public void sort(Student[] stu) { for(int i=0;i<stu.length-1;i++) { for(int j=0;j<stu.length-i-1;j++) { if(stu[j].score>stu[j+1].score) { //如果需要换序，交换的是数组的元素：Student对象！！！ //想象成String temp=stu[j]; Student temp= stu[j]; stu[j]=stu[j+1]; stu[j+1]=temp; } } } } }class Student{ int number;//学号 int state;//年级 int score;//成绩 //遍历数组方法二： public String info() { return “学号是：”+number+"，成绩是："+score+"，年级是："+state; } }第五题：public class Test20201220 { public static void main(String[] args) { //创建两个日期对象（格式是数组） MyDate[] date=new MyDate[2]; date[0]=new MyDate(); date[1]=new MyDate(); date[0].year=1997; date[0].month=01; date[0].day=20; date[1].year=1991; date[1].month=01; date[1].day=16; //遍历数组 Test20201220 test1=new Test20201220(); test1.print(date); } public void print(MyDate[] date) { for(int i=0;i<date.length;i++) { System.out.println(date[i].info()); } }}class MyDate{ int year; int month; int day; public String info() { return " 生日是："+year+month+day; }}复习（第194集）1.学习面向对象内容的三条主线（第4-6章）
* Java类及类的成员：属性、方法、构造器;代码块、内部类
* 面向对象的三大特征：封装性、继承性、多态性（抽象性）
* 其他关键字：this、super、static、final、abstract、interface、package、import

2.对象中类和对象的理解，并指出二者的关系：类的概念（抽象的、概念上的内容）具体例子：跟控制台交互，需要提供一个类，API接口提供了相关类Scanner类。对象（实实在在存在的一个个体，是类的实例化）：真正执行时，需要创建Scanner的对象，去操作它的功能方法，完成与控制台的交互。对象是由类派生出来的。3.面向对象思想的体现一：类和对象的创建和执行操作有哪三步？第一步：创建类第二步：创建类的对象（类的实例化）第三步：调用对象的结构（属性、方法）：“对象.属性”or“对象.方法”。4.声明的局部变量（相当于临时工，调用结束就出栈）保存在栈（stage）中5.类的方法内是否可以定义变量？是否可以调用属性？是否可以定义方法？是否可以调用方法？可以；可以；不可以；可以6.JVM内存结构
编译完源程序以后，生产一个多多个字节码文件。
我们使用JVM中的类的加载器和解释器对生产的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。

虚拟机栈，即为平时提到的栈结结构。我们将局部变量存储在栈结构中。
堆，我们将new出来的结构（比如:数组、对象）加载在堆空间中。补充：对象的属性（非 static）加载在堆空间中。
方法区：类的加载信息、常量池、静态域

7.属性vs局部变量
相同点（3点）：
1.定义数据结构变量名=变量值；
2.先声明后使用
3.仅在其对应的作用域中起效

不同点（4点）
1.成员变量：声明在一个类的{}中
局部变量：声明在方法内，方法形参，代码块内，构造器形参，构造器内部的变量
2.成员变量：可以用权限修饰符
局部变量：不可以使用权限修饰符
3.成员变量：在初始化时有默认值。
局部变量：在初始化时无默认值，需要先显式赋值后再使用
4.成员变量：加载在堆空间中（非static）
局部变量：加载在栈空间中

8.变量的分类：
方式一：按照数据类型

方式二：按照在类中声明的位置.

9.类的设计中，重要结构：方法

类中的方法的声明和使用
方法：描述类应该具有的功能。
比如：Math类：sqrt()\radom()\
```
Scanner类:nextXxx()...
```

Arrays类：对数组进行排序sort()\用二分法查找某个值得位置：binarySearch()\输出数组的值：toString()\比较两个数组是否相同：equals()\

1.举例
void 无返回值，其他的都有相应的返回值
public void eat() {}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation) {}
2.方法的声明：权限修饰符返回值类型方法名(形参列表（可选且可多于1个）){
```
                   方法体
```
```
        }
```
注意：static、final、abstract来修饰的方法、后面再讲
3.说明：
```
3.1权限修饰符：
```

    Java规定的4种权限修饰符：private、public、缺省、protected--->封装性在细说

3.2返回值类型：有返回值 vs 没有返回值

    3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，

        需要使用return关键字来返回指定类型的变量或常量。

    3.2.2如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，

        就不需要使用return，但是如果使用的话，只能“return;”，表示结束此方法。

    3.2.3我们定义方法该不该有返回值？

```
        1.题目要求
```

        2.凭经验：具体问题具体分析

3.3方法名：属于标识符，遵循标识符等的规则和规范，“见名知意”，命名规则（驼峰法）：xxxYyyZzz

3.4形参列表：方法可以声明0个、1个或多个形参。（形参不可以定义值）

    3.4.1格式：数据类型1 形参1，数据类型2 形参2

    3.4.2我们定义方法该不该定义形参？

```
        1.题目要求
```

        2.凭经验：具体问题具体分析

```
3.5方法体：方法功能的体现
```
5.方法的使用中：可以调用当前类的属性或方法

5.1特殊的：方法A中又调用了方法A：递归方法

```
5.2方法中不可以定义方法
```

10.return关键字的使用
1.使用范围：在方法体中
2.作用：a.结束方法
b.针对有返回值类型的方法，用“return 数据”的方式，结束方法且返回所要的数据
3.注意点：return后面不可以声明执行语句

4-5类的成员之二：方法（method）
“万事万物皆对象”的理解：
一、理解“万事万物皆对象”

1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
```
    >Scanner,String等（etc.）
```
```
    >文件：File
```

    >网络地址（网络资源）：URL

1. 涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

方法的重载

面试题：方法的重载与重写的区别？
throw\throw
String\StringBuffer\StringBuilder
Collection\Collections
final\finally\finalize

方法的重载（overload）
1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可

"两同一不同"：同一个类，相同方法名。

            参数列表不同：参数个数不同，参数类型不同。(参数个数、类型相同，但顺序不同也算不同)

2.举例：

 Arrays类中重载的sort()/binarySearch()

3.判断是否是重载：

        跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系

4.在通过对象调用方法时，如何确定某一个指定的方法：
```
a.方法名
```
```
b.参数列表
```

*/
public class Method {

       public static void main(String[] args) {Method me=new Method();me.getSum(1, 2);//1}//如下的4个方法构成了重载public void getSum(int i,int j) {System.out.println("1");}public void getSum(double i,int j) {System.out.println("2");}public void getSum(String i,int j) {System.out.println("3");}public void getSum(int j,String i) {System.out.println("4");}//不算重载/** public String getSum(int j,String i) {*    return "1";* }*//** public void getSum(int m,int n) {** }*///不算重载/** private void getSum(int i,int j) {** }*/

}

public class Method {

       public static void main(String[] args) {Method me=new Method();me.mOL(10);me.mOL(3,4);me.mOL("oi");}public void mOL(int i) {System.out.println(i*i);}public void mOL(int i,int j) {System.out.println(i*j);}public void mOL(String s) {System.out.println(s);}public void max(int i,int j) {int max=(i>j)?i:j;System.out.println(max);}public void max(double i,double j) {double max=(i>j)?i:j;System.out.println(max);}public void max(double i,double j,double h) {double max1=(i>j)?i:j;double max2=(max1>h)?max1:h;System.out.println(max2);}

}

可变个数的形参：例String…books

可变个数形参的方法
1.jdk 5.0新增内容
2.具体使用：

2.1可变个数形参的格式：数据类型...变量名

2.2当调用可变个数形参的方法时，传入的参数个数可以是：0个、1个、2个。。。

2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说：二者不能共存

2.5可变个数形参在方法的形参中，必须声明在末尾

2.6可变个数形参在方法的性参中，最多只能声明一个可变形参。

*/
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test=new MethodArgsTest();

   test.show(12);test.show("hello");test.show("hello","world");test.show();
}
public void show(int i) {}public void show(String...strings) {System.out.println(1);for (int i = 0; i < strings.length; i++) {System.out.println(strings[i]);}
}/*和String ...strings是相同的* public void show(String[] strs) {** }*///The variable argument type String of the method show must be the last parameter
public void show(int i,String... s) {}

}

值传递

关于变量的赋值
方法的形参的传递机制：值传递
1.形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
2.值传递机制：
如果参数是基本数据类型，此时实参赋给形参的实参真实存储的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

*/
public class Value {
public static void main(String[] args) {

   System.out.println("***********基本数据类型******** ");int m=10;int n=m;System.out.println(n+" "+m);//10 10n=20;System.out.println(n+" "+m);//20 10System.out.println("***********引用数据类型******** ");Order o1=new Order();o1.orderId=1001;Order o2=o1;System.out.println("o1:"+o1.orderId+",o2:"+o2.orderId);o2.orderId=1002;System.out.println("o1:"+o1.orderId+",o2:"+o2.orderId);//交换两个变量的值得操作int x=10;int y=20;Value test=new Value();test.swap(x, y);System.out.println(x+" "+y);//10 20
}public void swap(int m,int n) {int temp=m;m=n;n=temp;System.out.println(m+" "+n);//20 10
}

}
class Order{
int orderId;

}

public class ValueTransferTest1 {
public static void main(String[] args) {
Data data= new Data();

data.m=10;
data.n=20;
System.out.println(data.m+" "+data.n);ValueTransferTest1 test=new ValueTransferTest1();
test.swap(data);
System.out.println(data.m+" "+data.n);

}
public void swap(Data data) {
int temp=data.m;
data.m=data.n;
data.n=temp;

}
class Data{
int m;
int n;
}

15 0
20

错误写法，首位置的元素改变了

int[] arr=new int[]{1,2,3};
System.out.println(arr);//地址值

char[] arr1=new char[]{‘a’,‘b’,‘c’};
System.out.println(arr1);//abc，原因System.out.println(char[]）的方法就是用来遍历数组的

import java.util.Scanner;
public class PassObject {

   public static void main(String[] args) {Circle circle=new Circle();System.out.println("请输入数字");Scanner scan=new Scanner(System.in);int num=scan.nextInt();PassObject pass=new PassObject();pass.printAreas(circle, num);System.out.println("现在的radius是："+circle.radius);}public void printAreas(Circle c,int time) {System.out.println("Radius\t\tArea");//设置圆的半径for(int i=1;i<=time;i++) {c.radius=i;System.out.println(c.radius+"面积"+c.findArea());}c.radius =time +1;}

}

递归方法

递归方法的使用（了解）
1.一个方法体内调用它自身
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
*/
public class Recursion {

public static void main(String[] args) {
//例1：计算1~100之间所有自然数的和
//方式一：for循环
```
Recursion r=new Recursion();
System.out.println(r.getSum(100));
```
}
```
//方式二：递归
```
public int getSum(int n) {
if(n==1) {
return 1;
}else {
return n+getSum(n-1);
}
}

//1-100的乘积
public int getSum(int n) {
if(n==1) {
return 1;
}else {
return n*getSum(n-1);
}
}
}

//例3：已知有一个数列:f(0)=1,f(1)=4,f(n+2)=2f(n+1)+f(n),其中n是大于0的证书，求f(10)的值
public int getSum1(int n) {
if(n0) {
return 1;
}else if(n1) {
return 4;
}
else {
return 2getSum1(n-1)+getSum1(n-2);
}
}

//例4：斐波那契数列

public int getSum2(int n) {if(n==1||n==2) {System.out.println(n);return 1;}else {return getSum2(n-1)+getSum(n-2);}}
//例5：汉诺塔问题//例6：快排

4-7面向对象特征之一：封装与隐藏

/*

面向对象的特征一：封装与隐藏
一、问题的引入
当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值。这里，赋值操作
要受到属性的数据类型型和存储范围的制约。但是除此之外，没有其他制约条件。但是在实际问题中，我们往往需要给
属性赋值加入额外的限制条件。这个条件不能再属性声明时体现。我们只能通过方法进行限制条件的添加。（比如：setLegs()）
同时：我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的。
—>此时，针对于属性就体现了封装性。
二、封装性的体现：
我们将类的属性私有化，同时提供公共的方法来获取（getXxx）和设置（setX x）此属性的值
拓展：封装性的体现：a.如上b. 不对外暴露的私有方法c.单例模式…
三、封装性的体现，需要权限修饰符配合。
1.java规定的4中权限（从小到大排列）：private、缺省、protected、public
2.四种权限可以用来类及类的内部结构：属性、方法、构造器、内部类
3.具体的，：四种权限都可以用来修饰的内部结构：属性、方法、构造器、内部类

                       修饰类的话，只能用缺省或public

*/
public class Animal {
public static void main(String[] args) {
Animals a=new Animals();
a.name=“皮皮”;
//a.age=2;

   a.show();a.setLegs(-6);a.show();//a.legs=4;The field Animals.legs is not visibleSystem.out.println();
}

}
class Animals{
String name;
private int age;
private int legs;

//提供关于属性age的get和set方法
public void setAge(int a) {if(a>=0&&a<=30) {age=a;}else {age=0;}
}public int getAge() {return age;
}//对属性的设置
public void setLegs(int l) {if(l>=0&&1%2==0) {legs = l;}else {legs = 0;//或者抛出异常（暂时没有讲）}}//对属性的获取
public int getLegs() {return legs;
}public void eat() {System.out.println("进食");
}public void show() {System.out.println(name+age+legs);
}

}

四种访问权限修饰符

public class Order {

private int orderPrivate;
int orderDefault;
public int orderDePublic;private void methodPrivate() {orderPrivate =1;orderDefault =2;orderDePublic =3;
}void methodDefault() {orderPrivate =1;orderDefault =2;orderDePublic =3;
}public void methodPublic() {orderPrivate =1;orderDefault =2;orderDePublic =3;
}

}

public class PersonTest {
public static void main(String[] args) {
Person p=new Person();
p.setAge(50);
int a=p.getAge();
System.out.println(p.getAge());
}
}

public class Person {
int age;

void setAge(int i) {if(i>=0&&i<=130) {age=i;}else {System.out.println("请输入正确的年龄（0-130）");}
}int getAge() {return age;
}//绝对不要这样写！！！！
/** int doAge(int a) { age=a; return age; }*/

}

4-8类的成员之三：构造器（或构造方法）
/* 类的成员之三：构造器（或构造方法、constructor）的使用

construct：建设、建造。construction：CCB constructor：建造者
一、构造器的作用：
1.创建对象
2.初始化对象的属性
二、说明
1.如果没有显示的定义类的构造器的话：系统会自动提供一个空参的构造器
2.定义构造器的格式：权限修饰符类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器后，系统不再提供默认的空参构造器
5.一个类中，至少会有一个构造器
*/
public class Person {
public static void main(String[] args) {
//创建类的对象：new +构造器
Per p=new Per();
p.eat();
Per p1=new Per(“Tom”);
System.out.println(p1.name);
}
}
class Per{
//属性
String name;
int age;

//构造器
public Per() {
System.out.println(“Person()…”);
}

public Per(String n) {
name =n;
}

public Per(String n,int a) {
name =n;
age = a;
}

//方法
public void eat() {
System.out.println(“eat”);
}

public void study() {
System.out.println(“study”);
}
}

public class PersonTest {
public static void main(String[] args) {
Person p=new Person();
System.out.println(p.getAge());//18

   Person p1=new Person("Tom",15);System.out.println(p1.getName()+p1.getAge());//Tom 15}

}
public class Person {
private int age;
private String name;

public Person(String n,int a) {age=a;name=n;
}public Person() {age=18;}void setName(String s) {name =s;
}String getName() {return name;
}void setAge(int i) {if(i>=0&&i<=130) {age=i;}else {System.out.println("请输入正确的年龄（0-130）");}
}int getAge() {return age;
}

}

构造器

public class TriAngleTest {
public static void main(String[] args) {
TriAngle tri=new TriAngle(2.0,3.0);

   double area=tri.getBase()*tri.getHeight()/2;System.out.println(area);
}

}
public class TriAngle {
private double base;
private double height;

public TriAngle() {}public TriAngle(double x,double y) {base=x;height=y;
}double getBase() {return base;
}double getHeight() {return height;
}

}

public class Student {
String name;
int age;
String school;
String major;

public Student(String n,int a){name =n;age =a;
}public Student(String n,int a,String s){name =n;age =a;school=s;
}public Student(String n,int a,String s,String m){name =n;age =a;school=s;major =m;}

}

总结：属性赋值的先后顺序
①默认初始化
②显式初始化
③构造器中赋值
④通过“对象.方法”或“对象.属性”方式，赋值
以上操作的先后顺序：1-2-3-4

*/
public class UserTest {
public static void main(String[] args) {
User u=new User();
System.out.println(u.age);//1

   User u1=new User(2);u1.setAge(3);System.out.println(u1.age);//2
}

}
class User {
String name;
int age =1;

public User() {}public User(int a) {age=a;
}public void setAge(int a) {age =a;
}

}

JavaBean：1.类是公共的。2.有一个无参的公共构造器。3.有属性、且提供对应get、set方法

关键字：this的使用

this关键字的使用：
1.this可以用来修饰、调用：属性、方法、构造器
2.this修饰属性和方法：
```
this理解为：当前对象
```

2.1在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，

通常情况下，我们都选择省略“this.”，特殊情况下，如果方法的形参和类的属性重名时，我们必须显式

的使用“this.变量”的方式，表明此变量时属性，而非形参。

2.2在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用当前即将创建的对象属性或方法。但是，

通常情况下，我们都选择省略“this.”，特殊情况下，如果构造器方法的形参和类的属性重名时，我们必须显式

的使用“this.变量”的方式，表明此变量时属性，而非形参。

*3.this来修饰调用构造器

①我们在类的构造器中，可以显式的使用“this(形参列表);”方式，调用本类中指定的其他构造器

②构造器中不能国通“this(形参列表);”方式调用自己

③如果一个类中有n个构造器，最多有n-1构造器中能使用“this(形参列表);”

④规定：“this(形参列表);”必须声明在当前构造器中的首行

⑤构造器内部，最多只能声明一个“this(形参列表);”调用其他构造器

*/
public class PersonTest {
public static void main(String[] args) {
Person p1=new Person();

   p1.setAge(1);System.out.println(p1.getAge());
}

}
class Person{
private String name;
private int age;

public Person() {this.eat();
}public Person(String name) {this();//调用上面空参的构造器this.name = name;}public Person(int age) {this();//调用上面空参的构造器this.age = age;}public Person(String name,int age) {this(age);//调用上面空参的构造器this.name = name;//this.age = age;不需要这行了}public void setName(String name) {this.name = name;//this理解为当前对象，相当于声明的p1}public String getName() {return name;
}public void setAge(int age) {this.age = age;
}public int getAge() {return age;
}public void eat() {System.out.println("eat");this.study();//等于study();默认this省略
}public void study() {System.out.println("study");
}

}

public class BoyGirlTest {
public static void main(String[] args) {
Boy boy=new Boy(“rio”,21);
boy.shout();

    Girl girl=new Girl("junee",18);girl.marry(boy);Girl girl1=new Girl("祝英台",19);int compare=girl.compare(girl1);if(compare>0) {System.out.println("junee大");}else if (compare<0) {System.out.println("祝英台大");}else {System.out.println(一样的);}
}

}

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

public Boy() {}public Boy(String name, int age) {this.name = name;this.age = age;
}public Boy(String name) {super();this.name = name;
}
public void setName(String name) {this.name=name;
}public String getName() {return this.name;
}public void setAge(int age) {this.age=age;
}public int getAge() {return this.age;
}public void marry(Girl girl) {System.out.println("我想嫁"+girl.getName());
}public void shout() {if(this.age>=22) {System.out.println("结婚");}else {System.out.println("no");}
}

}

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

public Girl() {}public Girl(String name, int age) {this.name = name;this.age = age;
}
public void setName(String name) {this.name=name;
}public String getName() {return this.name;
}public void setAge(int age) {this.age=age;
}public int getAge() {return this.age;
}public void marry(Boy boy) {System.out.println("我想娶"+boy.getName());boy.marry(this);
}/**** @Description 比较两个对象的大小* @author yanlin_zhu* @version*date 2020年12月24日下午10:31:07* @param gril* @return 正数：当前对象大；负数：当前对象小；0：当前对象和形参对象相等*/
public int compare(Girl girl) {if(this.age >girl.age) {return 1;}else if (this.age <girl.age) {return -1;}else {return 0;}//简化版：return this.age-girl.age
}

}

第234集
public class Customer {

public static void main(String[] args) {Customer customer = new Customer("Jane","Smith");Account account=new Account(1000,2000.0,0.0123);customer.setAccount(account);customer.getAccount().deposit(100);customer.getAccount().withdraw(960);customer.getAccount().withdraw(2000);System.out.println("用户："+customer.getFirstName()+customer.getLastName()+"ID:"+customer.getAccount().getId());System.out.println("余额"+customer.getAccount().getBalance());
}private String firstName;
private String lastName;
private Account account;public Customer(String f, String l) {this.firstName = f;this.lastName = l;
}public String getFirstName() {return firstName;
}public String getLastName() {return lastName;
}public Account getAccount() {return account;
}public void setAccount(Account account) {this.account=account;
}

}

class Account {
private int id;
private double balance;//余额
private double annualInterestRate;//年利率

   public Account(int id, double balance, double annualInterestRate) {this.id = id;this.balance = balance;this.annualInterestRate = annualInterestRate;}public int getId() {return this.id;}public double getBalance() {return this.balance;}public double getAnnualInterestRate() {return this.annualInterestRate;}public void setID(int id) {this.id=id;}public void setBalance(double balance) {this.balance=balance;}public void setAnnualInterestRate(double annualInterestRate) {this.annualInterestRate=annualInterestRate;}//取钱public void withdraw(double amount) {if(this.balance<amount) {System.out.println("余额不足,取款失败");}else {System.out.println("成功取出"+amount);this.balance -=amount;System.out.println("余额为："+balance);}}//存钱public void deposit(double amount) {if(amount>0) {System.out.println("成功存入"+amount);this.balance +=amount;System.out.println("余额为："+balance);return;}}

}