第4章、面向对象编程(上)

学习面向对象内容的三条主线

1.Java类及类的成员

2.面向对象的三大特征

3.其它关键字

一、面向过程与面向对象

1、何谓“面向对象”的编程思想？

首先解释一下“思想”。

先问你个问题：你想做个怎样的人？

可能你会回答：我想做个好人，孝敬父母，尊重长辈，关爱亲朋……

你看，这就是思想。这是你做人的思想，或者说，是你做人的原则。

做人有做人的原则，编程也有编程的原则。这些编程的原则呢，就是编程思想。

2、面向过程(POP) 与 面向对象(OOP)

面向对象：Object Oriented Programming

面向过程：Procedure Oriented Programming

3、面向对象的三大特征

• 封装 (Encapsulation)
• 继承 (Inheritance)
• 多态 (Polymorphism)

4、面向对象的思想概述

• 程序员从面向过程的执行者转化成了面向对象的指挥者

• 面向对象分析方法分析问题的思路和步骤：

  • 根据问题需要，选择问题所针对的现实世界中的实体。
  • 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
  • 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
  • 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

import java.io.IOException;

/**
 * @author: huxingxin
 * @date: 2022/11/26 17:19:06
 * @description:
 * 一、Java面向对象学习的三条主线
 *  1、Java类及类的成员：属性、方法、构造器、代码块、内部类
 *  2、面向对象的三大特性：封装性、继承性、多态性、（抽象性）
 *  3、其它关键字：this、super、static、final、abstract、interface、package、import等
 *
 *  大处着眼，小处着手
 *
 * 二、人把大象装入冰箱
 *  1、面向过程：强调的是功能和行为，以函数作为最小单位，考虑怎么做
 *  （1）打开冰箱门
 *  （2）抬起大象，塞进冰箱
 *  （3）关闭冰箱门
 *
 *  2、面向对象：强调具备了功能的对象，以 类/对象 为 最小单位，考虑谁来做
 *
 *  人{
 *      打开(冰箱){
 *        冰箱.开门();
 *      }
 *      抬起(大象){
 *          大象.进入冰箱();
 *      }
 *      关闭(冰箱){
 *          冰箱.关门();
 *      }
 *  }
 *
 *  冰箱{
 *      开门(){}
 *      关门(){}
 *  }
 *
 * 大象{
 *      进入(冰箱){}
 * }
 *
 * 三、面向对象的两个要素
 *  类：对一类事务的描述，是抽象的、概念上的定义。
 *  对象：是实际存在的该类事物的个体，因而也称为实例(instance)。
 *  面向对象程序的设计重点就是类的设计
 *  设计类，就是设计类的成员
 */
public class OOPTest {
    public static void main(String[] args) throws IOException {

    }
}

5、练习

1、 我要开车去丽江，这句话包含的类有什么？

2、体会以下几个经典案例涉及到的类。

• 人在黑板上画圆
• 列车司机紧急刹车
• 售货员统计收获小票的金额
• 你把门关上了

3、抽象出下面系统中的“类”及其关系。

二、Java基本元素：类和对象

1、面向对象的思想概述

• 类(Class)和对象(Object)是面向对象的核心概念。
• • 类是对一类事物的描述，是抽象的、概念上的定义
  • 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
• “万事万物皆对象”

• 可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人
• 面向对象程序设计的重点是类的设计
• 类的设计，其实就是类的成员的设计

2、Java类及类的成员

现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同理，Java代码世界是由诸多个不同功能的类构成的。

现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么，Java中用类class来描述事物也是如此。常见的类的成员有：

• 属 性：对应类中的成员变量
• 行 为：对应类中的成员方法

Field = 属性 = 成员变量，Method = (成员)方法 = 函数

（1）类的成员构成 version 1.0

（2）类的成员构成 verson 2.0

（3）类的语法格式

（4）创建Java自定义类

//1、创建类，设计类的成员
public class People{
    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat(){
        System.out.println("人可以吃饭");
    }
    public void sleep(){
        System.out.println("人可以睡觉");
    }
    public void talk(String language){
        System.out.println("人可以说话，使用的语言是：" + language);
    }

}

步骤：

1. 定义类（考虑修饰符、类名）

2. 编写类的属性（考虑修饰符、属性类型、属性名、初始化值）

3. 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

练习：

定义Person、Animal、ClassRoom、Zoo等类，加以体会。

三、对象的创建和使用

/**
 * @author: huxingxin
 * @date: 2022/11/26 23:26:10
 * @description:
 * 一、设计类，其实就是设计类的成员
 *  属性 = 成员变量 = filed = 域、字段
 *  方法 = 成员方法 = 函数 = method
 *  创建类的对象 = 类的实例化 = 实例化类
 *
 * 二、类和对象的使用(面向对象思想的落地实现)
 *  1、创建类，设计类的成员
 *  2、创建类的对象
 *  3、通过 “对象.属性” 或 “对象.方法” 调用对象的结构
 *
 * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。(非static的)
 *     意味着：我们修改一个对象的属性a，则不影响另外一个对象属性a的值
 *
 * 四、对象的内存解析
 */
public class PeopleTest {
    public static void main(String[] args) {
        //2、创建People类的对象
        People people = new People();

        //3、调用对象的结构：属性、方法
        //调用属性：“对象.属性”
        people.name = "张三";
        people.isMale = true;
        System.out.println(people.name);

        //调用方法：“对象.方法”
        people.eat();
        people.sleep();
        people.talk("Chinese");


        People people1 = new People();
        System.out.println(people1.name);
        System.out.println(people1.isMale);

        //将people保存的对象地址值赋给people1，导致people和people1指向了堆空间中的同一个对象的实体。
        People people2 = people;
        System.out.println(people2.name);//张三

        people2.age = 10;
        System.out.println(people.age);//10


    }
}

//1、创建类，设计类的成员
class People{
    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat(){
        System.out.println("人可以吃饭");
    }
    public void sleep(){
        System.out.println("人可以睡觉");
    }
    public void talk(String language){
        System.out.println("人可以说话，使用的语言是：" + language);
    }

}

1、创建对象语法：

类名 对象名 = new 类名();

//2、创建People类的对象
People people = new People();

2、使用

“对象名.对象成员”的方式访问对象成员（包括属性和方法）

//3、调用对象的结构：属性、方法
//调用属性：“对象.属性”
people.name = "张三";
people.isMale = true;
System.out.println(people.name);

//调用方法：“对象.方法”
people.eat();
people.sleep();
people.talk("Chinese");

3、Java中类与对象

说明：如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

//2、创建People类的对象
People people = new People();
people.name = "张三";
people.isMale = true;
System.out.println(people.name);

People people1 = new People();
System.out.println(people1.name);
System.out.println(people1.isMale);

//将people保存的对象地址值赋给people1，导致people和people1指向了堆空间中的同一个对象的实体。
People people2 = people;
System.out.println(people2.name);//张三

people2.age = 10;
System.out.println(people.age);//10

类的访问机制：

在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过。）

在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

对象的产生

Person p1 = new Person();//执行完后的内存状态。其中类定义如下：
class Person{
    int age;
    void shout(){
        System.out.println(“oh,my god! 	I am ” + age);
    }
}

对象的使用

class PersonTest{
    public static void main(String[] args) { //程序运行的内存布局如下图
        Person p1 = new Person();
        Person p2 =  new Person();
        p1.age = -30;
        p1.shout();
        p2.shout();
    }
}

对象的生命周期

内存解析

• 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
• 通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。 方法执行完，自动释放。
• 方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

Person p1 = new Person();
p1.name = "Tom";
p1.isMale = true;
Person p2 = new Person();
sysout(p2.name);//null
Person p3 = p1;
p3.age = 10;

根据代码，画出内存图

class Car{
    String color = "red";
    int num = 4;
    void show(){
        System.out.println("color="+color+"..num="+num);
    }
}
class CarTest {
    public static void main(String[] args) {
        Car c1 = new Car(); //建立对象c1
        Car c2 = new Car(); //建立对象c2
        c1.color = "blue"; //对对象的属性进行修改
        c1.show(); //使用对象的方法
        c2.show();
    } }

匿名对象

• 我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。
• 如：new Person().shout();
• 使用情况
• 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
• 我们经常将匿名对象作为实参传递给一个方法调用。

package com.notes._1Java基础编程._4面向对象编程_上;

/**
 * @author: huxingxin
 * @date: 2022/11/29 15:08:47
 * @description:
 *  1、理解：我们创建的对象。没有显示的赋值给一个变量名，即为匿名对象
 *  2、特征：匿名对象只能调用一次
 *  3、使用：
 */
public class Demo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        System.out.println(phone);
        phone.sendEmail();
        phone.playGame();

        //匿名对象
        new Phone().playGame();

        new Phone().price = 1999;
        new Phone().showPrice();// 0.0

        //使用情景
        PhoneMall phoneMall = new PhoneMall();
        phoneMall.show(new Phone());

    }
}

class PhoneMall{
    public void show(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
}

class Phone{
    double price;

    public void sendEmail(){
        System.out.println("发送邮件");
    }

    public void playGame(){
        System.out.println("玩游戏");
    }

    public void showPrice(){
        System.out.println("手机的价格为：" + price);
    }
}

四、类的成员之一：属性

1、语法格式

修饰符 数据类型 属性名 = 初始化值 ;

• 说明1: 修饰符：常用的权限修饰符有：private、缺省、protected、public
  • 其他修饰符：static、final (暂不考虑)
• 说明2：数据类型：任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
• 说明3：属性名： 属于标识符，符合命名规则和规范即可。

2、变量的分类：成员变量与局部变量

在方法体外，类体内声明的变量称为成员变量。

在方法体内部声明的变量称为局部变量。

成员变量（属性）和局部变量的区别

成员变量vs局部变量的内存位置

/**
 * @author: huxingxin
 * @date: 2022/11/27 21:10:36
 * @description:  属性和局部变量的对比
 *  类中属性的使用
 *      成员变量 vs 局部变量
 *      1、相同点：
 *          （1）定义变量的格式：数据类型 变量名 = 变量值
 *          （2）先声明，后使用
 *          （3）变量都有其对应的作用域
 *      2、不同点
 *          （1）在类中声明的位置不同
 *              属性：直接定义在类的一对 {}
 *              局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
 *
 *          （2）关于权限修饰符不同
 *              属性：可以在声明属性时，指定其权限，使用权限修饰符
 *                  常用的权限修饰符：private、public、缺省、protected -->封装性
 *                  目前：大家声明属性时，都使用缺省就可以了
 *              局部变量：不可以使用权限修饰符
 *
 *           （3）默认初始化值的情况
 *              属性：类的属性，根据其类型，都有初始化值
 *                  整形（byte、short、int、long）: 0
 *                  浮点型（float、double）：0.0
 *                  字符型（char）：0 或者 '/u0000'
 *                  布尔型（boolean）：false
 *                  引用数据类型（类、数组、接口）：null
 *              局部变量：没有默认初始化值
 *                    意味着我们在调用局部变量之前，一定要显示赋值
 *                    特别的：形参在调用时，我们赋值即可
 *
 *              （4）在内存中加载的位置
 *                  属性：加载到堆空间中（非static）
 *                  局部变量：加载到栈空间中
 *
 *
 */
public class UserTest {
    public static void main(String[] args) {
        User user = new User();
        System.out.println(user.name);
        System.out.println(user.age);
        System.out.println(user.isMale);

        user.talk("中文");
        user.eat();
    }
}

class User{
    //属性（成员变量）
    String name;
    public int age;
    boolean isMale;

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

    public void eat(){
        String food = "烙饼";//局部变量
        System.out.println("北方人喜欢吃 " + food);

    }

}

对象属性的默认初始化赋值

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person及前面讲过的数组。

五、类的成员之二：方法

/**
 * @author: huxingxin
 * @date: 2022/11/27 21:33:41
 * @description:
 *  类中方法的声明和使用
 *
 *  方法：描述类应该具有的功能
 *  比如：Math类：sqrt()、random()
 *        Scanner类：next()
 *        Arrays类：sort()、binarySearch()、toString()、equals()
 *
 *  1、举例
 *     public void eat(){}
 *     public void sleep(int hour){}
 *     public String getName(){}
 *     public String getNation(String nation){}
 *
 *  2、方法的声明：权限修饰符 返回值类型 方法名(形参列表){
 *                     方法体
 *                 }
 *
 *     static、final、abstract 来修饰的方法，后面再讲
 *
 *  3、说明
 *      （1）关于权限修饰符：
 *            Java中规定的四种权限修饰符：private、public、缺省、protected --> 封装性再细说
 *
 *      （2）返回值类型：有返回值类型 vs 没有返回值类型
 *           （2.1）  如果有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或者常量，"return 数据"。
 *
 *                    如果没有返回值，则方法声明时，使用void来表示，通常，没有返回值的方法中就不使用return，如果使用的话，只能 "return;"，
 *                 表示结束此方法的意思。
 *
 *                     return后不可以声明表达式
 *
 *            （2.2）我们定义方法该不该有返回值
 *                  题目要求
 *                  凭经验：具体问题 具体分析
 *      （3）方法名：属于标识符，遵循标识符的规则和规范，见名知意
 *
 *      （4）形参列表：方法可以声明0个 1个 或者多个形参
 *         (4.1) 格式：数据类型1 形参1, 数据类型2 形参2, ...
 *        （4.2）我们定义方法时，该不该定义形参？
 *              题目要求
 *              凭经验：具体问题 具体分析
 *
 *       （5）方法体：方法功能的实现
 *
 *  4、return关键字的使用
 *      使用范围：使用在方法体中
 *      作用：
 *          结束方法
 *          针对于有返回值类型的方法，使用 "return 数据;" 返回所要的数据
 *      注意点：return关键字后面不可以声明执行语句
 *
 *  5、方法的使用：可以当前类的属性或方法
 *      特殊的：方法A中又调用了方法A：递归
 *     方法中不可以定义方法
 */
public class CustomerTest {
    public static void main(String[] args) {
        Customer customer = new Customer();
        customer.sleep(9);
    }
}

class Customer{
    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat(){
        System.out.println("客户吃饭");
        return;
        // return后不可以声明表达式
//        System.out.println();
    }

    public void sleep(int hour){
        System.out.println("休息了 " + hour + "个小时");
        eat();
    }

    public String getName(){
        return name;
    }

    public String getNation(String nation){
        String info = "我的国籍是 " + nation;
        return info;
    }
}

1、什么是方法(method、函数)

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。

将功能封装为方法的目的是，可以实现代码重用，简化代码。

Java里的方法不能独立存在，所有的方法必须定义在类里。

举例：

public class Person{
    private int age;
    public int getAge() { //声明方法getAge()
        return age; 
    }
    public void setAge(int i) { //声明方法setAge
        age = i; //将参数i的值赋给类的成员变量age
    }
}

2、方法的声明格式

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
    方法体程序代码
    return 返回值;
｝

• 修饰符：public,缺省,private, protected等
• 返回值类型：
  • 没有返回值：void。
  • 有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
• 方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
• 形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
• 返回值：方法在执行完毕后返还给调用它的程序的数据

​

3、方法的分类

按照是否有形参及返回值

4、方法的调用

方法通过方法名被调用，且只有被调用才会执行。

方法调用的过程分析

​

注 意：

方法被调用一次，就会执行一次

没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。

定义方法时，方法的结果应该返回给调用者，交由调用者处理。

方法中只能调用方法或属性，不可以在方法内部定义方法。

六、练习

1、练习1

编写教师类和学生类，并通过测试类创建对象进行测试

/**
 * @author: huxingxin
 * @date: 2022/11/28 9:08:04
 * @description:
 */
public class Test1 {
    public static void main(String[] args) {
        //创建对象 进行测试
        Student student = new Student();
        student.name = "张三";
        student.age = 20;
        student.major = "计算机";
        student.interests = "编程";
        String info = student.say();
        System.out.println(info);

        Teacher teacher = new Teacher();
        teacher.name = "李四";
        teacher.age = 30;
        teacher.teachAge = 7;
        teacher.course = "计算机";
        teacher.say();
    }
}

//创建Student类
class Student{
    String name;
    int age;
    String major;//专业
    String interests;//兴趣

    public String say(){
        return "姓名：" + name + " 年龄：" + age + " 专业：" + major + " 兴趣：" + interests;
    }
}

//创建Teacher类
class Teacher{
    String name;
    int age;
    int teachAge;
    String course;//课程

    public void say(){
        System.out.println("姓名：" + name + " 年龄：" + age + " 教学年龄：" + teachAge + " 课程：" + course);
    }
}

2、练习2

(1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”，调用showAge()方法显示age值，

调用addAge()方法给对象的age属性值增加2岁。

(2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。

/**
 * @author: huxingxin
 * @date: 2022/11/28 9:18:27
 * @description:
 *
 */
public class Test2 {
    /*
        要求：
        (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”，调用showAge()方法显示age值，
    调用addAge()方法给对象的age属性值增加2岁。
        (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
     */
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "张三";
        person.age = 30;
        person.sex = 0;

        person.study();
        person.showAge();
        int age = person.addAge(2);
        System.out.println("age: " + age);
    }
}

class Person{
    String name;
    int age;
    int sex;

    public void study(){
        System.out.println("studying");
    }

    public void showAge(){
        System.out.println("age: " + age);
    }

    public int addAge(int number){
        return age += number;
    }
}

3、练习3

/**
 * @author: huxingxin
 * @date: 2022/11/28 9:54:06
 * @description: 利用面向对象的编程方法，设计类Circle计算圆的面积。
 */
public class Test3 {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.radius = 1.2;
        double area = circle.getArea();
        System.out.println("area: " + area);
    }
}

class Circle{
    double radius;

    //计算圆的面积
    public double getArea(){
        return Math.PI * Math.pow(radius, 2);
    }
}

4、练习4

/**
 * @author: huxingxin
 * @date: 2022/11/28 10:05:05
 * @description:
 */
public class Test4 {
    public static void main(String[] args) {
        Test4 test4 = new Test4();
        int area = test4.method(4, 8);
        System.out.println("area: " + area);
    }
}

class Test4{
    /*
    3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形，在main方法中调用该方法。
     */
//    public void method(){
//        for (int i = 0; i < 10; i++){
//            for (int j = 0; j < 8; j++){
//                System.out.print("*");
//            }
//            System.out.println();
//        }
//    }


    /*
    3.2 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，
    并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
     */
//    public int method(){
//        for (int i = 0; i < 10; i++){
//            for (int j = 0; j < 8; j++){
//                System.out.print("*");
//            }
//            System.out.println();
//        }
//
//        return 10 * 8;
//    }

    /*
    3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，
    并计算该矩形的面积， 将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
     */
    public int method(int m, int n){
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++){
                System.out.print("*");
            }
            System.out.println();
        }

        return m * n;
    }
}

5、练习5

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：

1. 生成随机数：Math.random()，返回值类型double;
2. 四舍五入取整：Math.round(double d)，返回值类型long。

import java.util.Arrays;
/**
 * @author: huxingxin
 * @date: 2022/11/28 10:20:32
 * @description:
 */

public class _4练习5_对象数组 {
    public static void main(String[] args) {
        Student student = new Student();
        Student[] students = student.initStudents();
        student.searchState(students, 3);

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

        student.scoreSort(students);
        student.printStudent(students);
    }
}


class Student{
    int number;
    int state;
    int score;

    public void getInfo(){
        System.out.println(" number: " + number + " state：" + state + " score：" + score);
    }

    /**
     * 初始化数组
     * @return
     */
    public Student[] initStudents(){
        Student[] students = new Student[20];
        for (int i = 0; i < students.length; i++){
            int state = (int)(Math.random() * 9 + 1);
            int score = (int)(Math.random() * 101);

            Student student = new Student();
            student.number = i + 1;
            student.state = state;
            student.score = score;
            students[i] = student;
        }
        return students;
    }

    /**
     * 遍历学生信息
     * @param students 学生数组
     */
    public void printStudent(Student[] students){
        for (int i = 0; i < 20; i++){
            students[i].getInfo();
        }
    }

    /**
     * 查询指定年纪的学生
     * @param students 学生数组
     * @param state 年级
     */
    public void searchState(Student[] students, int state){
        //打印出3年级(state值为3）的学生信息。
        for (int i = 0; i < students.length; i++){
            if (students[i].state == state){
                students[i].getInfo();
            }
        }
    }

    /**
     * 根据分数排序
     * @param students 学生数组
     */
    public void scoreSort(Student[] students){
        //使用冒泡排序按学生成绩排序，并遍历所有学生信息
        for (int i = 0; i < students.length - 1; i++){
            for (int j = 0; j < students.length - 1 - i; j++){
                Student student = students[j];
                if (students[j].score > students[j + 1].score){
                    students[j] = students[j + 1];
                    students[j + 1] = student;
                }
            }
        }
    }
}

对象数组的内存解析

引用数据类型的变量，只能存储两类值: null 和 地址值（包含变量的数据类型）

六、再谈方法

1、方法的重载(overload)

/**
 * @author: huxingxin
 * @date: 2022/11/29 16:12:53
 * @description:
 *
 * 方法的重载
 *  1、定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
 *     两同一不同：同一个类、相同方法名
 *                参数列表不同：参数个数不同、参数类型不同
 *
 *  2、举例：
 *      Arrays类中重载的方法 sort() binarySearch()
 *
 *  3、判断是否是重载
 *      跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
 *
 *  4、在通过对象调用方法时，如何确定某一个指定的方法
 *      方法名 --> 参数列表
 */
public class OverloadDemo {
    public static void main(String[] args) {
        OverloadDemo overloadDemo = new OverloadDemo();
        overloadDemo.getSum(1,2);
    }


    //如下的四个方法都构成重载
    public void getSum(int i, int j){}

    public void getSum(double i, double j){}

    public void getSun(String s, int i){}

    public void getSum(int i, String s){}

//    public int getSum(int i, int j){}
//    public void getSum(int m, int n){}
//    private void getSum(int i, int j){}

}

重载的概念

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

重载的特点：

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

重载示例：

//返回两个整数的和
int add(int x,int y){return x+y;}

//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和
double add(double x,double y){return x+y;}

public class PrintStream {
    public static void print(int i) {……}
    public static void print(float f) {……}
    public static void print(String s) {……}
    public static void main(String[] args) {
        print(3);
        print(1.2f);
        print("hello!");
    }
}

使用重载方法，可以为编程带来方便。

例如，System.out.println()方法就是典型的重载方法，其内部的声明形式如下

public void println(byte x)
public void println(short x)
public void println(int x)
public void println(long x)
public void println(float x)
public void println(double x)
public void println(char x)
public void println(double x)
public void println()
……

重载练习

/**
 * @author: huxingxin
 * @date: 2022/11/29 16:50:18
 * @description:
 */
public class OverloadTest {
    public static void main(String[] args) {
        OverloadTest overloadTest = new OverloadTest();
        overloadTest.oML(4);
        overloadTest.oML(3, 4);
        overloadTest.oML("Hello Java");

        overloadTest.max(10, 20);
        overloadTest.max(30.0, 25.0);
        overloadTest.max(20.1, 20.1, 20.1);
    }


    /*
    2.编写程序，定义三个重载方法并调用。方法名为mOL。
        三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别 执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
        在主类的main ()方法中分别用参数区别调用三个方法。

    3.定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值，
    并分别调用三个方法。
     */

    public void oML(int i){
        System.out.println(Math.pow(i, 2));
    }

    public void oML(int i, int j){
        System.out.println(i * j);
    }

    public void oML(String s){
        System.out.println(s);
    }

    public void max(int i, int j){
        System.out.println(i > j ? i : j);
    }

    public void max(double i, double j){
        System.out.println(i > j ? i : j);
    }

    public void max(double i, double j, double k){
        if (i > j && i > k){
            System.out.println(i);
        }else if (j > i && j > k){
            System.out.println(j);
        }else {
            System.out.println(k);
        }
    }

}

2、可变个数的形参

/**
 * @author: huxingxin
 * @date: 2022/11/29 17:06:54
 * @description:
 *
 * 可变个数形参的方法
 *  1、JDK 5.0 新增的内容
 *  2、具体的使用
 *      可变个数形参的格式：数据类型... 变量名
 *      当调用可变个数形参的方法是，传入的参数个数可以是 0个 1个 2个 3个 ...
 *      可变个数形参的方法与本类中方法名相同，形参不同的方法构成重载
 *      可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载，换句话说，二者不能共存
 *      可变个数形参在方法的形参中，必须声明在末尾
 *      可变个数形参在方法的形参中，最多只能声明一个可变形参
 */
public class Demo {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.show("a", "b", "c");
    }


    //当调用可变个数形参的方法是，传入的参数个数可以是 0个 1个 2个 3个 ...
    public void show(String... str){
       for (int i = 0; i < str.length; i++){
           System.out.println(str[i]);
       }
    }

    //可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载，换句话说，二者不能共存
//    public void show(String[] str){} //本质上是一个数组

    //可变个数形参在方法的形参中，必须声明在末尾
    public void show(int i, String... str){}
}

说明：

1. 声明格式：方法名(参数的类型名 ...参数名)

2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个

3. 可变个数形参的方法与同名的方法之间，彼此构成重载

4. 可变参数方法的使用与方法参数部分使用数组是一致的

5. 方法的参数部分有可变形参，需要放在形参声明的最后

6. 在一个方法的形参位置，最多只能声明一个可变个数形参

public void test(String[] msg){
	System.out.println("含字符串数组参数的test方法");
}
public void test1(String book){
	System.out.println"****与可变形参方法构成重载的test1方法****");
}
public void test1(String ... books){
	System.out.println("****形参长度可变的test1方法****");
}
public static void main(String[] args){
    TestOverload to = new TestOverload();
    //下面两次调用将执行第二个test方法
    to.test1();
    to.test1("aa" , "bb");
    //下面将执行第一个test方法
    to.test(new String[]{"aa"});
}

3、方法参数的值传递机制

1、理解变量的赋值

/**
 * @author: huxingxin
 * @date: 2022/11/30 9:36:29
 * @description:
 *
 * 关于变量的赋值
 *      如果变量是基本数据类型，此时赋值的是变量所保存的数据值
 *      如果变量是引用数据类型，此时赋值的是变量所保存的地址值
 */
public class Demo {
    public static void main(String[] args) {

        //基本数据类型
        int m = 10;
        int n = m;
        System.out.println("m: " + m + ", n: " + n);

        n = 20;
        System.out.println("m: " + m + ", n: " + n);

        //引用数据类型
        Order order1 = new Order();
        order1.orderId = 1001;

        Order order2 = order1;
        System.out.println("order1.orderId: " + order1.orderId + ", order2.orderId: " + order2.orderId);

        order2.orderId = 1002;
        System.out.println("order1.orderId: " + order1.orderId + ", order2.orderId: " + order2.orderId);

    }

}

class Order{
    int orderId;
}

• 方法，必须由其所在类或对象调用才有意义。若方法含有参数：
  • 形参：方法声明时的参数
  • 实参：方法调用时实际传给形参的参数值
• Java的实参值如何传入方法呢？
• Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
  • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
  • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

2、基本数据类型的参数传递

public static void main(String[] args) {
    int x = 5;
    System.out.println("修改之前x = " + x);// 5
    // x是实参
    change(x);
    System.out.println("修改之后x = " + x);// 5
}
public static void change(int x) {
    System.out.println("change:修改之前x = " + x);
    x = 3;
    System.out.println("change:修改之后x = " + x);
}

3、引用数据类型的参数传递

public class Test{
    public static void main(String[] args) {
        Person obj = new Person();
        obj.age = 5;
        System.out.println("修改之前age = " + obj.age);// 5
        // x是实参
        change(obj);
        System.out.println("修改之后age = " + obj.age);// 3
    }
    
    public static void change(Person obj) {
        System.out.println("change:修改之前age = " + obj.age);
        obj.age = 3;
        System.out.println("change:修改之后age = " + obj.age);
    }

}

//其中Person类定义为：
class Person{
    int age; 
}

public class Test{
    public static void main(String[] args) {
        Person obj = new Person();
        obj.age = 5;
        System.out.println("修改之前age = " + obj.age);// 5
        // x是实参
        change(obj);
        System.out.println("修改之后age = " + obj.age);// 5
    }
    public static void change(Person obj) {
        obj = new Person();
        System.out.println("change:修改之前age = " + obj.age);
        obj.age = 3;
        System.out.println("change:修改之后age = " + obj.age);
    }
}

//其中Person类定义为：
class Person{
int age; 
}

import java.util.Arrays;

/**
 * @author: huxingxin
 * @date: 2022/11/30 9:49:25
 * @description:
 *
 * 方法的形参的传递机制: 值传递
 *      形参：方法定义时，声明的小括号内的参数
 *      实参：方法调用时，实际传递给参数的数据
 *
 *  参数传递机制：
 *      如果参数是基本数据类型，此时实参赋值给形参的是，实参真实存储的数据值。
 *      如果参数是引用数据类型，此时实参赋值给形参的是，实参存储数据的地址值。
 *
 *
 */
public class TransferTest {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;
        System.out.println("m: " + m + ", n: " + n);

        //基本数据类型
        TransferTest transferTest = new TransferTest();
        transferTest.swap(m, n);
        System.out.println("m: " + m + ", n: " + n);

        //引用数据类型
        Data data = new Data();
        System.out.println("data.m: " + data.m + ", data.n: " + data.n);
        transferTest.swap(data);
        System.out.println("data.m: " + data.m + ", data.n: " + data.n);

        //冒泡排序
        int[] arr = {1, 33, 45, 32, 12, 22, 7, -78, 9};
        for (int i = 0; i < arr.length - 1; i++){
            for (int j = 0; j < arr.length - 1 -i; j++){
                if (arr[j] > arr[j + 1]){
//                    int temp = arr[j];
//                    arr[j] = arr[j + 1];
//                    arr[j + 1] = temp;

                    //错误的
//                    transferTest.swap(arr[j], arr[j+1]);

                    //正确的
                    transferTest.swap(arr, j, j + 1);

                }
            }
        }
        System.out.println(Arrays.toString(arr));


    }

    public void swap(int m, int n){
        int temp;
        temp = m;
        m = n;
        n = temp;
    }

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

    /**
     * 将两个数值的交换 封装成一个方法
     * @param arr 数组
     * @param i 数组下标
     * @param j 数组下标
     */
    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }


}

class Data{
    int m = 10;
    int n = 20;
}

4、练习

练习1

以下程序的输出结果是什么

/**
 * @author: huxingxin
 * @date: 2022/12/1 0:15:35
 * @description:
 */
public class TransferTest1 {
    public static void main(String args[]) {
        TransferTest1 test = new TransferTest1();
        test.first();
    }
    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);// 20
    }
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);// 15  0
    }
}

class Value {
    int i = 15;
}

练习2

貌似是考查方法的参数传递

import java.io.PrintStream;

/**
 * @author: huxingxin
 * @date: 2022/12/1 9:18:17
 * @description:
 */
public class TransferTest2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        method(a, b);//需要在method方法被调用之后，仅打印出a=100, b=200，请写出method方法的代码
        System.out.println("a = " + a);
        System.out.println("b = " + b);

    }

    //第一种
//    public static void method(int a, int b){
//        a = 100;
//        b = 200;
//        System.out.println("a = " + a);
//        System.out.println("b = " + b);
//        System.exit(0);
//    }

    //第二种：重写 System.out.println(String s) 方法
    public static void method(int a, int b){
        PrintStream printStream = new PrintStream(System.out){
           @Override
           public void print(String s) {
               if (a == 10){
                   s = "a = 100";
               }else if (b == 10){
                   s = "b = 200";
               }
               super.print(s);
           }
        };
        System.setOut(printStream);
    }

}

练习3

微软：定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};

让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组

import java.util.Arrays;

/**
 * @author: huxingxin
 * @date: 2022/12/1 9:34:00
 * @description:
 */
public class TransferTest3 {
    public static void main(String[] args) {
        /*
        微软：定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
        让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组
         */
        int[] arr = new int[]{12,3,3,34,56,77,432};

        //错误 arr[0] 会直接变成了1
//        for (int i = 0; i < arr.length; i++){ //[1, 3, 3, 34, 56, 77, 432]
//            arr[i] = arr[i] / arr[0];
//        }

        //方法一: 用临时变量将arr[0]存储起来
        int temp = arr[0];
        for (int i = 0; i < arr.length; i++){
            arr[i] = arr[i] / temp;
        }

        //方法二：最佳方法 从后往前除
        for (int i = arr.length - 1; i >= 0; i--){
            arr[i] = arr[i] / arr[0];
        }


        System.out.println(Arrays.toString(arr));
    }
}

练习4

输出结果是什么

package com.notes._1Java基础编程._4面向对象编程_上._8再谈方法._5练习;

/**
 * @author: huxingxin
 * @date: 2022/12/1 9:43:38
 * @description:
 */
public class TransferTest4 {
    public static void main(String[] args) {
        int[] arr1 = new int[]{23, 43, 0, 12, -6};
        char[] arr2 = new char[]{'h', 'e', 'l', 'l', 'o'};

        //输出结果是什么
        System.out.println(arr1);//地址值：[I@39a054a5  public void println(Object x){}
        System.out.println(arr2);//遍历后的字符串：hello  public void println(char x[]){}
    }
}

练习5

（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积。
（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time)
在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
（3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示。

package com.notes._1Java基础编程._4面向对象编程_上._8再谈方法._5练习;

/**
 * @author: huxingxin
 * @date: 2022/12/1 10:00:29
 * @description: 将对象作为参数传递给方法
 */

/*
（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积。
（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time)
    在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
    例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
（3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示。
 */
public class PassObject {
    public static void main(String[] args) {
        PassObject passObject = new PassObject();
        Circle circle = new Circle();
        passObject.printAreas(circle, 5);
        System.out.println("当前半径值：" + circle.radius);

    }

    public void printAreas(Circle circle, int time){
        System.out.println("Radius \tArea");
        for (int i = 1; i <= time; i++){
            circle.radius = i; //设置圆的半径
            System.out.println(circle.radius + " \t" + circle.findArea());
        }
        circle.radius = time + 1;
    }
}

class Circle{
    double radius;

    public double findArea(){
        return Math.PI * Math.pow(radius, 2);
    }
}

4、递归(recursion)方法

递归方法：一个方法体内调用它自身。

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

练习1

/**
 * @author: huxingxin
 * @date: 2022/12/1 10:56:07
 * @description:
 *递归方法的使用（了解）
 * 1、递归方法：一个方法体内调用它自身
 * 2、方法递归包含了一种隐士的循环，它会重复执行某段代码、但这种重复执行无需循环控制。
 * 递归一定要向已知方向递归，
 */
public class RecursionTest {
    public static void main(String[] args) {

        //计算1-100之间所有自然数的和
        int sum1 = 0;
        for (int i = 0; i <= 100; i++){
            sum1 += i;
        }
        System.out.println(sum1);

        RecursionTest recursionTest = new RecursionTest();
        int sum2 = recursionTest.getSum(100);
        System.out.println(sum2);

        int product = recursionTest.getProduct(4);
        System.out.println(product);

        int product1 = recursionTest.getProduct1(2);
        System.out.println(product1);
    }

    //1、计算1-n之间所有自然数的和
    public int getSum(int n){
        if (n == 1){
            return 1;
        }
        return n + getSum(n -1);
    }

    //2、计算1-n之间所有自然数的乘积 n!
    public int getProduct(int n){
        if (n == 1){
            return 1;
        }
        return n * getProduct(n -1);
    }

    //3、已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0的整数，求f(10)的值
    // f(n + 2) - 2 * f(n + 1) 会陷入死循环
    public int getProduct1(int n){
        if (n == 0){
            return 1;
        }else if (n == 1){
            return 4;
        }
        return 2 * getProduct1(n - 1) + getProduct1(n - 2);
    }


}

练习2

/**
 * @author: huxingxin
 * @date: 2022/12/1 14:27:58
 * @description:
 */
/*
输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
1 1 2 3 5 8 13 21 34 55
规律：一个数等于前两个数之和
要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来
 */
public class FibonacciTest {
    public static void main(String[] args) {
        FibonacciTest fibonacciTest = new FibonacciTest();
        int fibonacci = fibonacciTest.getFibonacci2(10);
        System.out.println(fibonacci);
    }

    //用for循环实现
    public int getFibonacci1(int n){
        if (n == 1 || n == 2){
            return 1;
        }
        //从n = 3 开始进入循环 计算一次
        int a = 1;
        int b = 1;
        int temp;
        for (int i = 0; i < n - 2; i++){
            temp = a;
            a = b;
            b = temp + b;//一个数等于前两个数之和
        }
        return b;
    }

    //用while循环实现
    public int getFibonacci2(int n){
        if (n == 1 || n == 2){
            return 1;
        }

        //从n = 3 开始进入循环 计算一次
        int a = 1;
        int b = 1;
        int temp;
        while (n > 2){
            temp = a;
            a = b;
            b = temp + b;//一个数等于前两个数之和
            n--;
        }
        return b;
    }

    //用递归实现
    public int getFibonacci3(int n){
        if (n == 1 || n == 2){
            return 1;
        }
        return getFibonacci3(n - 1) + getFibonacci3(n - 2);
    }
}

七、OOP特征一：封装与隐藏

• 为什么需要封装？封装的作用和含义？
  • 我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
  • 我要开车，…
• 我们程序设计追求“高内聚，低耦合”。
  • 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
  • 低耦合 ：仅对外暴露少量的方法用于使用。
• 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。

class Animal {
    public int legs;
    public void eat(){
        System.out.println("Eating");
    }
    public void move(){
        System.out.println("Moving.");
    }
}
public class Zoo {
    public static void main(String args[]) {
        Animal xb = new Animal();
        xb.legs = 4;
        System.out.println(xb.legs);
        xb.eat();
        xb.move();
    }
}

1、信息的封装和隐藏

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

• 隐藏一个类中不需要对外提供的实现细节；
• 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
• 便于修改，增强代码的可维护性；

/**
 * @author: huxingxin
 * @date: 2022/12/2 9:00:06
 * @description: 3W：what? why? how?
 * 一、面型对象的特性一：封装与隐藏
 *  当我们创建一个对象的类以后，我们可以通过 “对象.属性” 的方式，对对象的属性进行赋值。
 *  这里，赋值的操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。
 *  但是，在实际问题当中，我们往往需要给属性赋值加入额外的限制条件，这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。
 *  比如 setLegs()，同时我们需要避免用户再使用 “对象.属性” 的方式进行赋值。则需要将属性声明为私有的(private)
 *  此时针对于属性就体现了封装性
 *
 * 二、封装性的体现
 *  我们将类的属性私有化(private)，同时，提供公共的方法来获取(getXxx)和设置(setXxx)
 *
 *      拓展：封装性的体现有很多
 *          （1） 如上
 *          （2）不对外暴露的私有的方法
 *          （3）单例模式 ...
 *
 * 三、封装性的体现，需要权限修饰符来配合
 *  1、Java规定的4种权限：private、缺省、protected、public
 *  2、4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
 *     修饰类的话只能用public、缺省
 *
 *  总结封装性：Java提供了4种权限修饰符来修饰类以及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
 */
public class AnimalTest {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.name = "大黄";
//        animal.age = 2; //'age' has private access
        animal.setAge(2);
//        animal.legs = 4; //'legs' has private access
        animal.setLegs(4);
        animal.show();

//        animal.legs = -4;
        animal.setLegs(-4);
        animal.show();

        int legs = animal.getLegs();
        System.out.println(legs);
    }
}

class Animal{
    String name;
    private int age;
//    int legs; //腿的个数
    private int legs; //腿的个数

    //对属性的设置
    public void setLegs(int l){
        if (l >= 0 && l % 2 == 0){
           legs = l;
        }else {
            legs = 0;
        }
    }

    //对属性的获取
    public int getLegs(){
        return legs;
    }

    //提供age的get和set方法
    public int getAge(){
        return age;
    }

    public void setAge(int a){
        if (age >= 0){
            age = a;
        }else {
            age = 0;
        }
    }

    public void eat(){
        System.out.println("动物进食");
    }

    public void show(){
        System.out.println("[ name = "  + name + ", age = " + age + ", legs = " + legs + " ]" );
    }
}

2、四种访问权限修饰符

Java权限修饰符public、protected、(缺省)、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

对于class的权限修饰只可以用public和default(缺省)。

• public类可以在任意地方被访问。
• default类只可以被同一个包内部的类访问。

3、练习

/**
 * @author: huxingxin
 * @date: 2022/12/2 15:11:00
 * @description:
 */
/*
创建程序,在其中定义两个类：Person和PersonTest类。定义如下：
用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。
在 PersonTest 类 中实例化 Person 类的对象 b ， 调 用 setAge() 和getAge()方法，体会Java的封装性。
 */
public class PeopleTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(200);
        int age = person.getAge();
        System.out.println("年龄为: " + age);
    }
}

/**
 * @author: huxingxin
 * @date: 2022/12/2 15:14:47
 * @description:
 */
public class Person {
    private int age;

    public void setAge(int a){
        if (a < 0 || a > 130){
            System.out.println("传入的数据非法");
            return;
        }
        age = a;
    }

    public int getAge(){
        return age;
    }
}

八、类的成员之三：构造器

/**
 * @author: huxingxin
 * @date: 2022/12/2 15:27:19
 * @description:
 *
 * 类的结构之三：构造器（或构造方法、constructor）的使用
 * construct：建设、构造 construction：CCB constructor：建设者
 *
 * 一、构造器的作用
 * 1、创建对象
 * 2、初始化对象的信息
 *
 * 二、说明
 * 1、如果没有显示的定义构造器的话，则系统默认提供一个空参的构造器
 * 2、定义构造器的格式：权限修饰符 类名(形参列表){}
 * 3、一个类中定义的多个构造器，彼此重载
 * 4、一旦我们显示的定义了类的构造器之后，系统就不再提供空参的构造器
 * 5、一个类中，至少有一个构造器
 *
 */
public class PersonTest {
    public static void main(String[] args) {
        //创建类的对象：new + 构造器
        Person person1 = new Person();
        person1.eat();

        Person person2 = new Person("张三");
        String name = person2.name;
        System.out.println(name);

    }
}

class Person{
    //属性
    String name;
    int age;

    //构造器
    public Person(){
        System.out.println("Person的构造器...");
    }

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

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

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

    public void study(){
        System.out.println("人学习...");
    }
}

1、构造器的特征

它具有与类相同的名称

它不声明返回值类型。（与声明为void不同）

不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

2、构造器的作用

创建对象；给对象进行初始化

如：Order o = new Order(); Person p = new Person(“Peter”,15);

如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自

动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

3、语法格式

修饰符 类名 (参数列表) {
    初始化语句；
}

4、举 例：

public class Animal {
    private int legs;
    // 构造器
    public Animal() {
        legs = 4;
    } 
    public void setLegs(int i) {
        legs = i;
    }
    public int getLegs() {
        return legs;
    }
}

创建Animal类的实例：Animal a = new Animal();
调用构造器，将legs初始化为4。

5、构造器分类

• 根据参数不同，构造器可以分为如下两类：
  • 隐式无参构造器（系统默认提供）
  • 显式定义一个或多个构造器（无参、有参）
• 注 意：
  • Java语言中，每个类都至少有一个构造器
  • 默认构造器的修饰符与所属类的修饰符一致
  • 一旦显式定义了构造器，则系统不再提供默认构造器
  • 一个类可以创建多个重载的构造器
  • 父类的构造器不可被子类继承

6、构造器重载

构造器一般用来创建对象的同时初始化对象。如

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

构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。

public class Person{
    public Person(String name, int age, Date d) {this(name,age);…}
    public Person(String name, int age) {…}
    public Person(String name, Date d) {…}
    public Person(){…}
}

构造器重载，参数列表必须不同

构造器重载举例

public class Person { 
    //构造器重载举例
    private String name;
    private int age;
    private Date birthDate;
    public Person(String n, int a, Date d) {
        name = n;
        age = a;
        birthDate = d;
    }
    public Person(String n, int a) {
        name = n;
        age = a;
    }
    public Person(String n, Date d) {
        name = n;
        birthDate = d;
    }
    public Person(String n) {
        name = n;
        age = 30;
    }
}

7、属性赋值过程

/**
 * @author: huxingxin
 * @date: 2022/12/2 16:41:40
 * @description:
 *
 * 总结：属性赋值的先后顺序
 * （1）默认初始化
 * （2）显示初始化
 * （3）构造器初始化
 * （4）通过 “对象.方法” 或者 “对象.属性”方式进行赋值
 *
 * 以上操作的先后顺序 （1） （2） （3） （4）
 */
public class UserTest {
    public static void main(String[] args) {
        User user = new User();
        int age1 = user.getAge();
        System.out.println("age: " + age1);

        user.setAge(100);
        int age2 = user.getAge();
        System.out.println("age: " + age2);
    }
}

class User{
    String name;
    int age = 1;

    public User(){
        age = 2;
    }

    public int getAge() {
        return age;
    }

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

• 截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位置，并指明赋值的先后顺序。
  • 赋值的位置：
    • ① 默认初始化
    • ② 显式初始化
    • ③ 构造器中初始化
    • ④ 通过“对象.属性“或“对象.方法”的方式赋值
  • 赋值的先后顺序：
  • ① - ② - ③ - ④

8、JavaBean

• JavaBean是一种Java语言写成的可重用组件。
• 所谓javaBean，是指符合如下标准的Java类：
  • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性，且有对应的get、set方法
• 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP
  页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

JavaBean示例

/**
 * @author: huxingxin
 * @date: 2022/12/2 16:58:00
 * @description:
 *
 * JavaBean是一种Java语言写的可重用的组件
 * 所谓JavaBean，是指符合以下标准的Java类
 * （1）类是公共的
 * （2）有一个无参的公共的构造器
 * （3）有属性，且有对应的get、set方法
 */
public class Custom {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public Custom() {
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

9、UML类图

1. +表示 public 类型， - 表示 private 类型，#表示protected类型
2. 方法的写法: 方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型

10、练习

练习1

/**
 * @author: huxingxin
 * @date: 2022/12/2 16:22:03
 * @description:
 */
/*
定一个Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。

修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
 */
public class PersonTest {

    public static void main(String[] args) {
        Person person = new Person();
        int age = person.getAge();
        System.out.println("age: " + age);

        Person person1 = new Person(27, "张三");
        int age1 = person1.getAge();
        String name1  = person1.getName();
        System.out.println("age:" + age1 + ", name: " + name1);

    }
}

/**
 * @author: huxingxin
 * @date: 2022/12/2 16:21:56
 * @description:
 */
public class Person {
    private int age;
    private String name;

    public Person(){
        age = 18;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

练习2

/**
 * @author: huxingxin
 * @date: 2022/12/2 16:28:02
 * @description:
 */
/*
编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。
此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
 */
public class TriAngleTest {
    public static void main(String[] args) {
        TriAngle triAngle = new TriAngle(20, 10);
        double base = triAngle.getBase();
        double height = triAngle.getHeight();
        double area = base * height / 2;
        System.out.println("三角形的面积：" + area);
    }

}

/**
 * @author: huxingxin
 * @date: 2022/12/2 16:27:56
 * @description:
 */

public class TriAngle {
    private double base; //底边长
    private double height;//高

    public TriAngle() {
    }

    public TriAngle(double b, double h){
        base = b;
        height = h;
    }

    public double getBase() {
        return base;
    }

    public void setBase(double base) {
        this.base = base;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
}

九、关键字：this

/**
 * @author: huxingxin
 * @date: 2022/12/2 22:04:49
 * @description:
 *
 * this关键字的使用
 * 1、this可以用来修饰、调用：属性、方法、构造器
 * 2、this修饰属性和方法
 *  this理解为当前对象 或 当前正在创建的对象
 *
 *      2.1 在类的方法中，我们可以使用 “this.属性” 或 “this.方法” 的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略 “this.”。
 *  特殊情况下，如果方法的形参和类的属性重名时，我们必须显示的使用 “this.属性”，表明此变量是属性，而非形参。
 *
 *      2.2 在类的构造器中，我们可以使用 “this.属性” 或 “this.方法” 的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略 “this.”。
 *  特殊情况下，如果方法的形参和类的属性重名时，我们必须显示的使用 “this.属性”，表明此变量是属性，而非形参。
 *
 * 3、this调用构造器
 *      3.1 我们在类的构造器中，可以显示的使用 “this(形参列表)” 方式，调用本类中指定的其它构造器。
 *      3.2 构造器中不能通过 “this(形参列表)” 方式调用自己
 *      3.3 如果一个类中有n个构造器，则最多有 n-1 个构造器中使用了 “this(形参列表)”
 *      3.4 规定：“this(形参列表)” 必须声明在当前构造器的首行。
 *      3.5 构造器内部，最多只能声明一个 “this(形参列表)” 方式，用来调用其他构造器。
 */
public class PersonTest {
    public static void main(String[] args) {

    }
}

class Person{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

1、this是什么？

• 在Java中，this关键字比较难理解，它的作用和其词义很接近。
  • 它在方法内部使用，即这个方法所属对象的引用；
  • 它在构造器内部使用，表示该构造器正在初始化的对象。
• this 可以调用类的属性、方法和构造器
• 什么时候使用this关键字呢？
• 当在方法内需要用到调用该方法的对象时，就用this。
• 具体的：我们可以用this来区分属性和局部变量。
• 比如：this.name = name;

2、使用this，调用属性、方法

1. 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。

2. 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量

3. 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找

class Person{ 
    // 定义Person类
    private String name ;
    private int age ;
    public Person(String name,int age){
        this.name = name ; 
        this.age = age ; 
    }
    public void getInfo(){
        System.out.println("姓名：" + name) ;
        this.speak();
    }
    public void speak(){
        System.out.println(“年龄：” + this.age);
    }
}

当前正在操作本方法的对象称为当前对象。

class Person{ 
    // 定义Person类
    String name;
    Person(String name){
        this.name = name;
    }
    public void getInfo(){
        System.out.println("Person类 --> " + this.name) ; 
    }
    public boolean compare(Person p){
        return this.name==p.name;
    } 
}
public class PersonTest{
    public static void main(String args[]){
        Person per1 = new Person("张三") ;
        Person per2 = new Person("李四") ;
        per1.getInfo() ; // 当前调用getInfo()方法的对象是per1
        per2.getInfo() ; // 当前调用getInfo()方法的对象是per2
        boolean b = per1.compare(per2);
    } 
}

3、使用this调用本类的构造器

this可以作为一个类中构造器相互调用的特殊格式

class Person{ 
    // 定义Person类
    private String name ;
    private int age ;
    public Person(){ // 无参构造器
        System.out.println("新对象实例化") ;
    }
    public Person(String name){
        this(); // 调用本类中的无参构造器
        this.name = name ;
    }
    public Person(String name,int age){
        this(name) ; // 调用有一个参数的构造器
        this.age = age;
    }
    public String getInfo(){
        return "姓名：" + name + "，年龄：" + age ;
    } 
}

4、注意：

• 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
• 明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
• 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
• "this(形参列表)"必须声明在类的构造器的首行！
• 在类的一个构造器中，最多只能声明一个"this(形参列表)"

练习

十、关键字：package、import

/**
 * @author: huxingxin
 * @date: 2022/12/3 23:44:05
 * @description:
 *
 * 一、package关键字的使用
 * 1、为了更好的实现项目中类的管理，提供包的概念
 * 2、使用package声明类或接口所属的包，声明在源文件的首行
 * 3、包属于标识符，遵循标识符的命名规则、规范，“见名知意”
 * 4、每 . 一次，就代表一层文件目录
 *
 * 补充：同一个包下，不可以命名同名的类、接口
 *      不同的包下，可以命名同名的类、接口
 *
 * 二、import关键字的使用
 * import: 导入
 * 1、在源文件中显示的使用import结构导入指定包下的类、接口
 * 2、声明在包的声明和类的声明之间
 * 3、如果需要导入多个结构，并列写出即可
 * 4、可以使用 “xxx.*” 的方式可以导入xxx这个包下的所有结构
 * 5、如果使用的类或接口是 java.lang 包下定义的，则可以省略import结构
 * 6、如果使用的类或接口是本包下定义的，则也可以省略import结构
 * 7、如果在源文件中，使用了不同包下的同名的类，至少有一个类需要以全类名的方式显示
 * 8、使用 “xxx.*” 方式表明可以调用xxx包下的所有结构，但是如果使用的是xxx子包下的结构，则仍需要显式的导入
 *
 * 9、import static: 导入指定类或接口中的静态结构 属性和方法
 */
public class Demo {
}

1、关键字 - packag

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为：

package 顶层包名.子包名 ;

举例：pack1\pack2\PackageTest.java

//指定类PackageTest属于包pack1.pack2
package pack1.pack2; 

public class PackageTest{
    public void display(){
        System.out.println("in method display()");
    }
}

包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；

包通常用小写单词标识。通常使用所在公司域名的倒置：com.atguigu.xxx

（1）源文件布局：

（2）包的作用：

• 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式

• 包可以包含类和子包，划分项目层次，便于管理

• 解决类命名冲突的问题

• 控制访问权限

• 例：某航运软件系统包括：一组域对象、GUI和reports子系统

（3）MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展

示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

（4）JDK中主要的包介绍

1. java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能
2. java.net----包含执行与网络相关的操作的类和接口。
3. java.io ----包含能提供多种输入/输出功能的类。
4. java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5. java.text----包含了一些java格式化相关的类
6. java.sql----包含了java进行JDBC数据库编程的相关类/接口
7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
   B/S C/S

2、关键字 - import

• 为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。
• 语法格式：
  • import 包名. 类名;
• 应用举例：

//import pack1.pack2.*;表示引入pack1.pack2包中的所有结构
import pack1.pack2.Test; 

public class PackTest{
    public static void main(String args[]){
        //Test类在pack1.pack2包中定义
        Test t = new Test(); 
        t.display();
    }
}

注意：

1. 在源文件中使用import显式的导入指定包下的类或接口

2. 声明在包的声明和类的声明之间。

3. 如果需要导入多个类或接口，那么就并列显式多个import语句即可

4. 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。

5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。

6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。

7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。

8. import static组合的使用：调用指定类或接口下的静态的属性或方法