2、Java面向对象

JavaSE

发布日期: 2022-05-28

更新日期: 2022-06-01

文章字数: 13.6k

阅读时长: 53 分

阅读次数:

面向对象是最重要的一章，java 是一门纯面向对象编程语言, 我们后面写的所有程序都是在面向对象的基础上编写的。面向对象难在思想和语法上，真正应用的时候会不知不觉的渗透在你的代码里，好多程序员写程序会写, 但是为什么这样写? 不知道，所以本章很多都是理解和需要思考的东西.
在本章你要学的重点知识点:

类与对象
构造方法
访问权限
继承
多态 ( 最重要 )
抽象和接口
内存分析

其他知识点不是说不重要. 相对而言. 最重要的是上面这几个。
面向对象和面向过程：
讲面向对象之前, 还要再提两个概念, 毕竟没有对比就没有伤害：
面向过程:
从名字上可以看出来, 编程的思路是按照事务的发展流程而编写的，最典型的例子就是把大象装冰箱总共分几步? 第一步, 把冰箱门打开,
第二步, 把大象装进去,
第三步.把冰箱门关上。
优点: 思路简单, 写起来也简单
缺点: 维护困难，代码量越大, 越难维护。
面向对象:
一切以对象为中心，我们扮演的是上帝的角色。比如, 同样是大象进冰箱, 用面向对象的思维来解决的话就是, 创建一个大象, 然后告诉大象, 进冰箱里面去，具体怎么进冰箱由大象来完成。面向对象的思维可以把”我”的工作减少到最低，由对象来完成具体的操作。
优点: 超强的可扩展性，可维护性。
缺点: 上手比较难, 尤其是刚开始就接触面向对象。

类的组成

定义一个类的基本格式：

[修饰符] class 类名{
	0到多个构造器
	0到多个成员变量
	0到多个方法
	0到多给初始化块
}

修饰符可以写 public final abstract 或者不写，java 类名要用大驼峰写法(PrimaryStu 首字母大写的驼峰)。
一个 java 源文件（即文件后缀名为.java 的文件）可以写多个类，但是里面只能有一个用 public 修饰的 class。

构造器函数

构造器也叫构造方法或者构造函数,构造器与类名相同，没有返回值，连 void 都不能写;
构造器定义格式：

[修饰符]与类名相同的名(形参列表){
	构造器方法体代码
}

构造器函数名称与类名相同，没有返回值，不能写 void 。
如果类中没有手动添加构造器，编译器会默认添加一个无参构造器。
如果手动添加了构造器（无论什么形式），默认构造器就会消失，因为构造器可以重载。

成员变量

成员变量是定义在类中，方法体之外的变量(即类变量+实例变量)。实例变量在创建对象的时候实例化；
成员变量可以被类中方法、构造方法和特定类的语句块访问。
修饰符(public–protected–private)三选一、static、final，使用 static 修饰就是静态变量了(类变量)

类变量：独立于方法之外的变量，用 static 修饰。
局部变量：类的方法中的变量。
实例变量（全局变量）：独立于方法之外的变量，不过没有 static 修饰。

public class Variable{
  static int allClicks=0; // 类变量
  String str="hello world"; // 实例变量
  public void method(){
     int i =0; // 局部变量
   }
  }

局部变量

局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是 0，布尔型变量的默认值是 false，引用类型变量的默认值是 null。变量的值可以在声明时指定，也可以在构造方法中指定；实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

类变量

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法构造方法和语句块之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为 public/private，final 和 static 类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
静态变量在程序开始时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName 的方式访问。
类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

方法

Java 方法是语句的集合，它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合方法包含于类或对象中，方法在类中被创建，在其他地方被引用

void printf(){
  System.out.println(111);
	}

上面是一个无参的返回值为空的方法，参数可以加，返回值也可以是 int 型也可以是别的类型。
方法的定义：

[修饰符]方法的返回值类型 方法名称(形参列表){
	//方法体代码
	[return 返回值;]
}

方法的修饰符(public protected private)三选一、static、final、synchronize、native，使用 static 就是静态方法了

代码块

初始化代码块：将一些变量、语句（如打印语句）放到一个{}，主是用来初始化一些值的，它的优先级比构造函数要高，一些需要多次使用但又是固定的值可以放进初始化块中。
使用 static 就是静态初始化块了，静态初始化块优先级最高，多次实例化时只执行一次

一、类与对象

类是对具体事务的描述，对某一类事务的总结，对事物的归类。比如车是一个大类包括轿车 suv mpv 房车等等。
对象是什么? 对象就是具体的一辆车比如你购买的一辆宝马 X6，就是具体要执行操作的事务。

定义类

public class Car {  }

我们对车要进行描述，描述车需要有两个标准去描述, 1. 车有什么属性, 2. 车能干什么.
属性: 使用成员变量来描述属性
动作: 使用成员方法来描述动作
成员变量是什么? 很简单, 之前不是学过变量么. 我们之前的变量是写在 main 方法里的. 这里的成员变量指的是直接写在类里的变量叫成员变量. 比如. 车有颜色, 车有品牌, 车有排量等等。
成员方法是什么? 就是我们之前学习的方法. 把前面的 static 去掉就是成员方法. 关于 static 后面我们会讲，这里不用纠结，直接干掉就行。好了, 车能执行哪些动作? 跑, 跳高, 游泳等等。

public class Car {
     //成员变量. 可以初始化，也可以只声明不初始化
     String color;   // 汽车有颜色
     String brand = "奔驰";   // 汽车有品牌, 所有车都是奔驰
     String displacement;  // 汽车有排量
     //方法
     public void run(){
         System.out.println("破车会跑");
     }
     public void jump(){
         System.out.println("神车~~ 会跳高");
     }
     public void swim(){
         System.out.println("我的车会游泳");
     }
 }

类实例化对象

public static void main(String[] args) {
     Car c = new Car(); // 创建对象
 }

Car c =new Car();
这句话就是传说中的创建对象了.
注意, 这里其实是一个赋值操作, 那根据赋值操作的特点. 肯定要先执行等号右边的代码, 然后赋值给等号左边. 我们挨个分析.
new Car(); new 表示创建, 新建. 后面跟的是类名+括号. 整个这句话你可以理解为创建一个车类型的对象. 那这个车是根据 Car 类创建的. 所以这个对象一定符合类的定义. 这个很好理解. 用你的图纸造的车. 肯定符合你图纸上设计的样子.
Car c 这是个啥? 对比一下你瞬间秒懂
String a …… 没错. 就是声明了一个变量. c 是 Car 类型的. 只不过在面向对象的世界里变量是没有市场的. 大家都叫它引用. 这也就是我们讲的第二大数据类型, 引用数据类型. 说的就是咱们写的类. 声明出来的变量.
整体合起来就是: 创建一个车类的对象. 然后赋值给变量 c. 以后变量 c 就是使用的这辆车.

OK, 对象创建出来了. 接下来. 怎么用呢？

Car c = new Car();
c.color = "红色"; // 汽车的颜色设置成红色
c.displacement = "3.6T"; // 排量
//c.seat = 5; // 报错. 在类中你没有写这个属性.
System.out.println(c.color);
System.out.println(c.brand);
System.out.println(c.displacement);
c.run();
c.jump();
c.swim();

类里没有的属性你不能乱用.
总结: 类其实就是对某一类事物的归类和描述. 对象是通过类创建的，类是抽象概念, 对象是具体。

二、this 关键字

this 是啥? 我们看一个例子

public class Car {
     String color;
     int seat;
     String displacement;
     public void run(){
         System.out.println(color + "颜色的车在跑");
     }
     public static void main(String[] args) {
         Car c = new Car();
         c.color = "红色";
         c.seat = 5;
         c.displacement = "1.6";
         c.run();
     }
 }

这里注意. 在 run 方法里我们使用了一次 color 变量,此时我们发现可以正常使用.
我们可以发现, 此时使用的 color 是对象里的 color, 那如果我给 run()传递一个参数也叫 color 呢?

public class Car {
     String color;
     int seat;
     String displacement;
     public void run(String color){
         System.out.println(color + "颜色的车在跑");	//绿色颜色的车在跑
         System.out.println(this.color + "颜色的车在跑");		//红色颜色的车在跑
     }
     public static void main(String[] args) {
         Car c = new Car();
         c.color = "红色";
         c.seat = 5;
         c.displacement = "1.6";
         c.run("绿色");
     }
 }

方法查找变量的顺序: 方法内部(局部) > 对象
说白了就是就近原则, 那此时我即想用局部变量又想用对象中的变量,怎么进行区分呢? 此时就需要用到 this 关键字.

在 java 中, this 表示当前类的对象
啥叫当前类的对象,就是正在执行这个方法的对象.
c.run() => 在 run 中 this 就是 c

总结：this 可以帮我们在类中获取到对象的任何信息。如果没有命名冲突，可以省略this，但我们不推荐省略。

this()与 super()使用详解

参考：https://blog.csdn.net/lncsdn_123/article/details/79025525
https://www.cnblogs.com/hasse/p/5023392.html

三、构造方法

构造的意义就是可以帮我们在创建对象的时候给对象传递一些信息.
构造方法的语法:

public 类名(参数….){
}

注意: 构造方法的名字必须和类名一致.

public class Car{
     String name;
     String color;
     int seat;
     public Car(String name, String color, int seat){
         this.name = name; // 相当于p.name = name
         this.color = color; // 相当于p.color = color
         this.seat = seat; // 相当于p.seat = seat
         System.out.println("我就是一个可怜的构造方法");
     }
     public static void main(String[] args){
         Car p = new Car("大黄蜂", "绿色", 5); // 创建对象的时候. 后面这个小括号其实就是在调用构造方法
         System.out.println(p.name);
         System.out.println(p.color);
         System.out.println(p.seat);
     }
 }

总结: 构造方法存在的意义就是在对象在创建的时候给对象设置一些属性.
注意: 每个类都会有构造方法，如果不写, java 会自动创建一个没有参数的构造方法.
但是, 自己写了构造方法了就覆盖掉无参的构造方法

构造方法的重载

想这么一个事儿, 我们可以在创建对象的时候给对象传递一些信息, 通常都是在构造方法里设置一些属性. 那如果现在我写一个”大侠”类, 里面会有很多个属性,

public class DaXia{
     String name;
     String waihao;
     int age;
     String bangPai;
 }

好了, 接下来我们去创建大侠, 比如, 创建一个"岳不群", 那在创建岳不群的时候, 需要给出: 名字, 年龄, 帮派.

外号和口头禅对于岳不群而言都不需要，那如果是创建一个武松呢? 需要给出: 名字, 年龄, 帮派,外号. 这就会产生一个分歧，有些大侠有外号, 有些大侠没有外号，并且, 我们知道在创建对象的时候，我们是默认调用构造方法的. 那就需要我们写两个构造方法来满足两种不同的大侠，但是构造方法的名字还必须是类名，也就意味着, 我们要写两个名字相同的方法。在上一章里学过, 方法的名字相同参数的个数或者类型不同, 叫方法的重载。没错, 这里需要我们重载构造方法。

public class DaXia{
     String name;
     String waihao;
     int age;
     String bangPai;
     public DaXia(String name, int age, String bangPai){
         this.name = name;
         this.age = age;
         this.bangPai = bangPai;
     }
     public DaXia(String name, int age, String bangPai, String waihao){
         this.name = name;
         this.age = age;
         this.bangPai = bangPai;
         this.waihao = waihao;
     }
 }

聪明的你应该又发现一个问题,两个构造方法的写法太像了. 能不能简化一下呢? OK. 没问题. 我们还可以使用 this 来调用当前类中的其他构造方法

public class DaXia{
     String name;
     String waihao;
     int age;
     String bangPai;
     public DaXia(String name, int age, String bangPai){
         this.name = name;
         this.age = age;
         this.bangPai = bangPai;
     }
     public DaXia(String name, int age, String bangPai, String waihao){
         this(name, age, bangPai); 	// 调用自己类中的其他构造方法
         this.waihao = waihao;
     }
 }

this 的两个作用:

表示当前类的对象, 可以访问成员变量和成员方法

可以调用当前类中的其他构造方法(重载的构造方法名都是与类名一致，通过传参不同调不同的构造方法)

小练习

1.用面向对象的思维来模拟 LOL 里的盖伦上阵杀敌 2.植物大战僵尸

植物类 ZhiWu：包含 name hp attack 字段，和 fight 方法
僵尸类 JiangShi：包含 name hp attack 字段，和 eat 方法
程序入口类 Client：创建植物对象，僵尸对象，调用 zw.fight() 调用 js.eat()

ZhiWu.java

public class ZhiWu {
    String name;
    int hp;     //血量
    int attack;     //攻击力
    //构造方法
    public ZhiWu(String name,int hp,int attack){
        this.name = name;
        this.hp = hp;
        this.attack = attack;
    }
    //植物打僵尸
    public void fight(JiangShi js){
        System.out.println("植物"+this.name+"正在打僵尸"+js.name);
        //僵尸血量减少
        js.hp -= this.attack;
        System.out.println("僵尸的血量剩余："+js.hp);
    }
}

JiangShi.java

public class JiangShi {
    String name;
    int hp;     //血量
    int attack;     //攻击力
    //构造方法
    public JiangShi(String name,int hp,int attack){
        this.name = name;
        this.hp = hp;
        this.attack = attack;
    }
    //僵尸吃植物
    public void eat(ZhiWu zw){
        System.out.println("僵尸"+this.name+"正在吃植物"+zw.name);
        //植物血量减少
        zw.hp -= this.attack;
        System.out.println("植物的血量剩余："+zw.hp);
    }
}

Client.java

public class Client {
    public static void main(String[] args) {
        ZhiWu zw = new ZhiWu("豌豆射手",1000,5);
        JiangShi js = new JiangShi("铁头僵尸",800,10);
        //植物打僵尸
        zw.fight(js);
        //僵尸吃植物
        js.eat(zw);
    }
}

四、static 静态字段和静态方法

假设, 我们现在回到清朝. 给清朝人上户口. 那此时就需要写一个类来装关于清朝人的信息

public class Person{
     String name;
     String country;
     String address;
     public Person(String name, String country, String address){
         this.name = name;
         this.country = country;
         this.address = address;
     }
 }

接下来, 创建 2 个人

public static void main(String[] args){
     Person p1 = new Person("李大猛", "大清", "北京珠市口八大胡同");
     Person p2 = new Person("花花", "大清", "北京朝阳门外");
}

OK. 很 easy. 但是, 我们想想啊. 大清亡了. 改成民国了. 那这时候程序怎么办呢?

public static void main(String[] args){
     Person p1 = new Person("李大猛", "大清", "北京珠市口八大胡同");
     Person p2 = new Person("花花", "大清", "北京朝阳门外");
     p1.country = "民国";
     p2.country = "民国";
}

是不是每个人的 country 属性都要改一下. 为什么呢?
两个对象分别是两块独立的内存区域，里面的内容也都是独立的，所以必然要改两次。但是, 你要知道，我国人民众多啊，这得改到什么时候去。那如果能把 country 这一项作为共享的数据，所有的对象都共享那是不是改起来就容易了，也就是说. 想办法变成这样
这样改一份就 OK 了. 那怎么才能让 country 变成共享的呢? 就是咱今天要学的 static.
static 表示静态，被 static 修饰的变量会被所有的对象共享, 并且在内存里只会保留一份.

public class StaticTest {
    public String name;
    public int age;
    public static String country = "china";
    {
        System.out.println("这里是普通初始化块");
    }
    static {
        System.out.println("这里是静态初始化块");
    }
    public StaticTest(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("这里是构造方法");
    }
    public static void MyStaticFunc(){
        System.out.println("我是静态方法MyStaticFunc,国家="+StaticTest.country);
    }
    public void ShowNameFunc(){
        System.out.println("我是方法ShowNameFunc，name="+this.name+" ,age="+this.age);
    }
    public static void main(String[] args) {
        StaticTest obj1 = new StaticTest("zhangsan",18);
        StaticTest.MyStaticFunc();      //静态方法通过类调用
		//this.ShowNameFunc();        //main主函数也是一个静态方法，不能使用this
        obj1.ShowNameFunc();
    }
}
//打印结果
这里是静态初始化块
这里是普通初始化块
这里是构造方法
我是静态方法MyStaticFunc,国家=china
我是方法ShowNameFunc，name=zhangsan ,age=18

类的执行顺序：

总结：静态字段/方法属于类，p1 p2 是类 Person 创建的实例，实例对象可以访问类的静态字段/方法。静态字段/方法是在类实例化之前创建( this==实例)，因此静态方法中不能使用 this 且不能调用非静态方法（类中没有加 static 的方法）

public class StaticTest {
    public String name;
    public int age;
    public static String country = "china";
    {
        System.out.println("这里是普通初始化块");
    }
    static {
        System.out.println("这里是静态初始化块");
    }
    public StaticTest(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("这里是构造方法");
    }
    public static void MyStaticFunc(){
        System.out.println("我是静态方法MyStaticFunc,国家="+StaticTest.country);
    }
    public void ShowNameFunc(){
        System.out.println("我是方法ShowNameFunc，name="+this.name+" ,age="+this.age);
    }
    public static void main(String[] args) {
        StaticTest obj1 = new StaticTest("zhangsan",18);
        StaticTest.MyStaticFunc();      //静态方法通过类调用
//        this.ShowNameFunc();        //main主函数也是一个静态方法，不能使用this
        obj1.ShowNameFunc();
        Person p1 = new Person("李大猛", "北京珠市口八大胡同");
        Person p2 = new Person("花花", "北京朝阳门外");
        Person.country = "民国";
        System.out.println(p1.country);
        System.out.println(p2.country);
        Person.setCountry("中华人民共和国");
        System.out.println(p1.country);
        System.out.println(p2.country);
    }
}
class Person {
    static String country;
    String name;
    String address;
    public static void setCountry(String country){
//        System.out.println(this.name);      //静态方法中不能使用对象，即不能用this
        System.out.println("修改之前的静态字段Person.country="+Person.country);     //可以使用静态字段
        Person.country = country;
    }
	//构造方法
    public Person(String name, String address) {
        this.name = name;
        this.address = address;
    }
}

五、包和导包

https://www.liaoxuefeng.com/wiki/1252599548343744/1260467032946976
随着代码越写越多. 咱们不可能一直这样在 src 里创建 java 文件了，就好比你看片你不可能把所有的电影都堆桌面, 对吧, 你肯定要准备几个文件夹, 然后对这些片片进行分类, 哪些好看, 哪些无码, 哪些重口味~~，一样的咱们的代码也是啊，不可能就这么堆 src 里，时间长了不好管理啊
windows 操作系统使用文件夹来装不同的文件，在 java 里使用包来管理不同的 java 文件
怎么创建包? 看着

右键-> 新建-> package

注意: 包名一般用公司域名的翻转. 一般都是 com 或者 org 开头. 还有一些公司会用 net 开头，然后就是项目名, 最后一般都是功能模块名. 比如你先在写的是 qq 的聊天窗口那就可以: com.qq.talk

创建出来的包是这样个样子的. 但是如果你去文件系统里看. 它是这样的.

所谓的”.”其实就是文件夹.

OK. 接下来我们到包里创建一个 java 文件看看

我们发现, 现在写的代码的第一行多了这样一句话叫package com.xyq.bao; package 表示当前文件所属的包.
package 需要注意的点:

必须放在有效代码的第一行. 不可以写在别处.
package 后面的代码必须和文件系统的路径一致.

一个包 OK 了. 那如果是多个包呢? 我们到 src 位置创建一个新包

idea 会自动帮我们分开,很人性化.
接下来. 我们到 dao 里写一个 Person 类.

package com.xyq.dao;
public class Person {
     String name;
     String address;
     public Person(String name, String address){
         this.name = name;
         this.address = address;
     }
     public void chi(){
         System.out.println(this.name + "正在吃东西");
     }
 }

我们到 bao 里调用这个类

package com.xyq.bao;
public class TestPerson {
     public static void main(String[] args) {
         Person p1 = new Person("武大郎", "阳谷县"); // 这行报错
     }
 }

我们发现程序报错. 原因是. 自己包里没有这个叫 Person 的东西. 就好比, 你在你自己的房间里喊楼下的人. 听不见. 所以呢. 你需要打电话把楼下的人叫上来. 然后你俩面对面了. 你说什么他都能听到了. 此时, 我们需要导包,
语法:

import 包.类

package com.xyq.bao;		//第一行
import com.xyq.dao.Person; // 导包
public class TestPerson {
     public static void main(String[] args) {
         Person p1 = new Person("武大郎", "阳谷县");
         p1.chi();
     }
 }

在 idea 中导包非常简单，只需要将鼠标放到需要导入的类上按快捷键 Alt+Enter，即可自动导包
聪明的你一定想起来了，Scanner 不就这样么，对于 Scanner System 这类包属于 java.lang

不需要导包:

在自己包里

java.lang 包. 我们用的 String Scanner System.out.println()就是这个包里的.

六、修饰符

Java 中的修饰符分为 3 类：

权限修饰符：public、default 默认、protected、private
状态修饰符：static、final
抽象修饰符：abstract

1）访问权限修饰符

这个很好理解, 你的东西你肯定不希望别人随意的看随意的访问对吧， java 程序也是这样，不是啥都是对外的。有些东西自己享用就好了，有些东西是留给自己后代的，还有些东西是自己这一片邻居可以访问的，最后还有一些是大家都能访问的。
java 一共四种访问权限，参考：菜鸟教程

权限分类	当前类	子孙类	同一包（子类或无关类）	不同包（子类）	不同包（无关类）
public	√	√	√	√	√
protected	√	√	√	√	×
default	√	√	√	×	×
private	√	×	×	×	×

package com.xyq.bao;
public class Person {
     String def = "def"; // 默认啥都不写就是default权限
     public String pub = "pub"; // 公共的
     private String pri = "pri"; // 自己的
     public static void main(String[] args) {
         Person p = new Person();
         // 自己类里,都没问题
         System.out.println(p.def);
         System.out.println(p.pub);
         System.out.println(p.pri);
     }
 }

自己包里的其他类里试试:

package com.xyq.bao;
public class TestPackagePerson {
     public static void main(String[] args) {
         Person p = new Person();
 //      自己包里private不行了
         System.out.println(p.def);
         System.out.println(p.pub);
 //      System.out.println(p.pri); // 报错了
     }
 }

换个包试试

package com.xyq.baowai;
import com.xyq.bao.Person;
public class TestPackagePerson {
     public static void main(String[] args) {
         Person p = new Person();
 //      包外面的其他类. 只有public可以
         System.out.println(p.pub);
 //      System.out.println(p.def); // 报错了
 //      System.out.println(p.pri); // 报错了
     }
 }

一般情况, 我们很少用包访问权限. 这种权限并不舒服. 说白了. 你家里的东西要么是都能让人看的, 要么就是自己用的. 很少会专门准备一些东西给你的邻居用的. 程序也一样. 很少会用默认的访问权限.

2）状态修饰符

final 修饰的特点：

修饰方法：表明该方法是最终方法，不能被重写
修饰变量：表明该变量是常量，不能再次被赋值
修饰类：表明该类是最终类，不能被继承

final 修饰局部变量

变量是基本类型：final 修饰指的是基本类型的数据值不能改变
变量是引用类型：final 修饰指的是引用类型的地址值不能改变，但是地址里面的内容可以改变

static 关键字是静态的意思，可以修饰成员变量、成员方法
static 修饰特点：

被类的所有对象共享
可以通过类名调用（也可以通过对象名调用，推荐使用类名调用）
static 修饰的静态方法只能访问静态成员和静态方法
非静态方法可以访问静态成员和静态方法也可以访问非静态成员和非静态方法

七、getter 和 setter

GetterSetter.java 定义了私有属性 name age

package com.xiaomi.entity;
public class GetterSetter {
    private String name;
    private int age;
    //获取name
    public String getName() {
        return name;
    }
    //设置name
    public void setName(String name) {
        if(name.length() >1){
            this.name = name;
        }else{
            this.name = "匿名";
        }
    }
    //获取age
    public int getAge() {
        return age;
    }
    //设置age
    public void setAge(int age) {
        if(age<0){
            this.age = 0;
        }else{
            this.age = age;
        }
    }
    public void chi(){
        System.out.println(this.name+"在吃东西");
    }
}

包下面的其他类 TestGS 访问和设置 GetterSetter.java 中的私有属性

package com.xiaomi.entity;
public class TestGS {
    public static void main(String[] args) {
        GetterSetter obj1 = new GetterSetter();
//    obj1.name = "周杰伦";      //name是私有
        obj1.setName("周杰伦");
        obj1.setAge(-1);
        obj1.chi();
        System.out.println(obj1.getAge());
    }
}

上面例子中我们把成员变量用 private 保护起来，然后给出 set 和 get 方法, 在外界访问这个属性的时候，就需要使用 set 和 get 方法了. 那这里的 get 和 set 就是 getter 和 setter 方法.
上面发现对私有属性的保护要重写 get set 方法很浪费时间，IDEA 帮我们提供了快捷方法
快捷键: 空白处, 右键-> generate -> getter and setter
一键生成 get set 方法

八、继承

1.继承小结

继承是面向对象编程的一种强大的代码复用方式；
Java 只允许单继承，所有类最终的根类是Object；
protected允许子类访问父类的字段和方法；
子类的构造方法可以通过super()调用父类的构造方法；
可以安全地向上转型为更抽象的类型；
可以强制向下转型，最好借助instanceof判断；
子类和父类的关系是 is，has 关系不能用继承。

2.基本用法

继承: 子类可以自动拥有父类中除了私有内容外的其他所有内容。
语法:

public class 子类 extends 父类{
}

那什么样的逻辑我们可以写成继承关系呢? 当出现 xxx 是一种 xxxx 的时候，就可以用继承关系。比如,学生是人，
黑熊精是妖怪，猫狗是动物。 1.首先定义了Person类：

class Person {
    private String name;
    private int age;
    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

2.现在假设需要定义一个Student类，字段如下：

class Student {
    private String name;
    private int age;
    private int score;
    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
    public int getScore() { … }
    public void setScore(int score) { … }
}

仔细观察，发现Student类包含了Person类已有的字段和方法，只是多出了一个score字段和相应的getScore()、setScore()方法。
能不能在Student中不要写重复的代码？
这个时候，继承就派上用场了。
继承是面向对象编程中非常强大的一种机制，它首先可以复用代码。当我们让Student从Person继承时，Student就获得了Person的所有功能，我们只需要为Student编写新增的功能。
Java 使用extends关键字来实现继承：

class Person {
    private String name;
    private int age;
    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}
class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;
    public int getScore() { … }
    public void setScore(int score) { … }
}

可见，通过继承，Student只需要编写额外的功能，不再需要重复代码。
注意：子类自动获得了父类的所有字段，严禁定义与父类重名的字段！（否则就是子类重写父类字段/方法）

在 OOP 的术语中，我们把Person称为超类（super class）/父类（parent class）/基类（base class），把Student称为子类（subclass）/扩展类（extended class）。叫的最多的还是父类子类

继承树

注意到我们在定义Person的时候，没有写extends。在 Java 中，没有明确写extends的类，编译器会自动加上extends Object。所以，任何类，除了Object，都会继承自某个类。下图是Person、Student的继承树：

Java 只允许一个 class 继承自一个类，因此，一个类有且仅有一个父类。只有Object特殊，它没有父类。
类似的，如果我们定义一个继承自Person的Teacher，它们的继承树关系如下：

protected

希望父类的某个属性/方法能被子类重写，但不希望被其他类自由访问，可以使用 protected 来修饰。
继承有个特点，就是子类无法访问父类的private字段或者private方法。例如，Student类就无法访问Person类的name和age字段：

class Person {
    private String name;
    private int age;
}
class Student extends Person {
    public String hello() {
        return "Hello, " + name; 	// 编译错误：无法访问name字段
    }
}

这使得继承的作用被削弱了。为了让子类可以访问父类的字段，我们需要把private改为protected。用protected修饰的字段可以被子类访问：

class Person {
    protected String name;
    protected int age;
}
class Student extends Person {
    public String hello() {
        return "Hello, " + name; 	// OK!
    }
}

因此，protected关键字可以把字段和方法的访问权限控制在继承树内部，一个protected字段和方法可以被其子类，以及子类的子类所访问，后面我们还会详细讲解。

super

super关键字表示父类（超类）。子类引用父类的字段时，可以用super.fieldName。例如：

class Person {
    protected String name;
    protected int age;
}
class Student extends Person {
    public String hello() {
        return "Hello, " + super.name;		//name  this.name  super.name 效果一样
    }
}

实际上，这里使用super.name，或者this.name，或者name，效果都是一样的。编译器寻找路径是：自己类 –> 父类 ,自己类中没有就去父类中找。
但是，在某些时候，就必须使用super。我们来看一个例子：

public class Main {
    public static void main(String[] args) {
        Student s = new Student("Xiao Ming", 12, 89);
    }
}
class Person {
    protected String name;
    protected int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Student extends Person {
    protected int score;
    public Student(String name, int age, int score) {
        this.score = score;
    }
}

运行上面的代码，会得到一个编译错误，大意是在Student的构造方法中，无法调用Person的构造方法。
这是因为在 Java 中，任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会自动帮我们自动加一句super();，所以Student类的构造方法实际上是这样：

class Student extends Person {
    protected int score;
    public Student(String name, int age, int score) {
        super(); 	// 但是父类中的构造方法是带参数，因此这里报错
        this.score = score;
    }
}

但是，当前Person类并没有无参数的构造方法，因此，编译失败。
解决方法是调用Person类存在的某个构造方法。例如：

class Student extends Person {
    protected int score;
    public Student(String name, int age, int score) {
        super(name, age); // 调用父类的构造方法Person(String, int)
        this.score = score;
    }
}

这样就可以正常编译了！
因此我们得出结论：如果父类没有默认的构造方法(即我们重写了父类的构造方法)，子类就必须显式调用super()并给出参数以便让编译器定位到父类的一个合适的构造方法。
这里还顺带引出了另一个问题：即子类不会继承任何父类的构造方法。子类默认的构造方法是编译器自动生成的，不是继承的。

子类的构造方法中第一句默认是super()调用父类的无参构造方法，如果想要调用父类的有参构造方法需要手动写super("xiong",26)，所以我们写类时一般都会定义一个无参构造方法。

3.向上转型

如果一个引用变量的类型是Student，那么它可以指向一个Student类型的实例：

Student s = new Student();

如果一个引用类型的变量是Person，那么它可以指向一个Person类型的实例：

Person p = new Person();

现在问题来了：如果Student是从Person继承下来的，那么，一个引用类型为Person的变量，能否指向Student类型的实例？

Person p = new Student(); // ???

测试一下就可以发现，这种指向是允许的！
这是因为Student继承自Person，因此，它拥有Person的全部功能。Person类型的变量，如果指向Student类型的实例，对它进行操作，是没有问题的！
这种把一个子类类型安全地变为父类类型的赋值，被称为向上转型（upcasting）。
向上转型实际上是把一个子类型安全地变为更加抽象的父类型：

Student s = new Student();
Person p = s; 	// upcasting, ok
Object o1 = p; 	// upcasting, ok
Object o2 = s; 	// upcasting, ok

注意到继承树是Student > Person > Object，所以，可以把Student类型转型为Person，或者更高层次的Object。

4.向下转型

和向上转型相反，如果把一个父类类型强制转型为子类类型，就是向下转型（downcasting）。例如：

Person p1 = new Student(); 	// upcasting, ok
Person p2 = new Person();
Student s1 = (Student) p1; 	// ok
Person s2 = (Person) p2; 	// ok，自己对自己强转
Student s2 = (Student) p2; 	// runtime error! ClassCastException!父类不能转到子类

如果测试上面的代码，可以发现：
Person类型p1实际指向Student实例，Person类型变量p2实际指向Person实例。在向下转型的时候，把p1转型为Student会成功，因为p1确实指向Student实例，把p2转型为Student会失败，因为p2的实际类型是Person，不能把父类变为子类，因为子类功能比父类多，多的功能无法凭空变出来。
因此，向下转型很可能会失败。失败的时候，Java 虚拟机会报ClassCastException。

`instanceof`操作符

为了避免向下转型出错，Java 提供了instanceof操作符，可以先判断一个实例究竟是不是某种类型：

Person p = new Person();
System.out.println(p instanceof Person); // true
System.out.println(p instanceof Student); // false
Student s = new Student();
System.out.println(s instanceof Person); // true
System.out.println(s instanceof Student); // true
Student n = null;
System.out.println(n instanceof Student); // false

instanceof实际上判断一个变量所指向的实例是否是指定类型，或者这个类型的子类。如果一个引用变量为null，那么对任何instanceof的判断都为false。
利用instanceof，在向下转型前可以先判断：

Person p = new Student();
if (p instanceof Student) {
    // 只有判断成功才会向下转型:
    Student s = (Student) p; // 一定会成功
}

从 Java 14 开始，判断instanceof后，可以直接转型为指定变量，避免再次强制转型。例如，对于以下代码：

Object obj = "hello";
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.toUpperCase());
}

可以改写如下：

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String s) {
            // 可以直接使用变量s:
            System.out.println(s.toUpperCase());
        }
    }
}

使用instanceof variable这种判断并转型为指定类型变量的语法时，必须打开编译器开关--source 14和--enable-preview。

5.区分继承和组合

考察下面的Book类：

class Book {
    protected String name;
    public String getName() {...}
    public void setName(String name) {...}
}

这个Book类也有name字段，那么，我们能不能让Student继承自Book呢？

class Student extends Book {
    protected int score;
}

显然，从逻辑上讲，这是不合理的，Student不应该从Book继承，而应该从Person继承。
究其原因，是因为Student是Person的一种，它们是 is 关系，而Student并不是Book。实际上Student和Book的关系是 has 关系。
具有 has 关系不应该使用继承，而是使用组合，即Student可以持有一个Book实例：

class Student extends Person {
    protected Book book;
    protected int score;
}

因此，继承是 is 关系，组合是 has 关系。
参考：https://blog.csdn.net/weixin_43819113/article/details/90273844
练习：

Main.java

public class Main {
	public static void main(String[] args) {
		Person p = new Person("小明", 12);
		//此时需要显示的创建被组合的对象 b1
		Book b1 = new Book("三体",89.2);
		Student s = new Student("小红", 20, 99,b1);
		s.BookContent();
		// TODO: 定义PrimaryStudent，从Student继承，新增grade字段:
		Student ps = new PrimaryStudent("小军", 9, 87,b1,5);
		System.out.println(ps.getScore());
		ps.BookContent();
	}
}

Person.java

public class Person {
	protected String name;
	protected int age;

	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;
	}
}

Student.java

public class Student extends Person {
	protected int score;
	protected Book book;
	public Student(String name, int age, int score,Book book) {
		super(name, age);
		this.book = book;
		this.score = score;
	}
	public int getScore() {
		return score;
	}
	//重写该方法
	public void BookContent(){
		System.out.println("我是Student类，"+this.name+"有这本书！");
		this.book.BookContent();
	}
	public void BookSale(){
		System.out.println("这本书销量非常好，已经供不应求了！");
	}
}

PrimaryStudent.java

public class PrimaryStudent extends Student {
	protected int grade;
	public PrimaryStudent(String name, int age, int score,Book b1,int grade) {
		super(name,age,score,b1);
		this.grade = grade;
	}
}

Book.java

public class Book {
    protected String bookname;
    protected Double price;
    protected String author;
    protected String type;
    public Book(String bookname,Double price){
        this.bookname = bookname;
        this.price = price;
    }
    public void BookContent(){
        System.out.println("我是Book类，这本书的书名是："+this.bookname+"，价格是："+this.price);
    }
}

九、Java 多态

Java 多态特点

多态—顾名思义就是一种事物表现出不同的形态；举个例子：汤姆猫既是猫类（拥有猫捉老鼠的特性）也是动物类（动物会跑会吃东西的特性）。

多态中成员访问特点

成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边

这两句话怎么理解呢？

Animal a1 = new Dog();
a1.name
成员变量：编译时 Animal 类中必须要有 name 属性，执行时也是运行的 Animal 中的 name

Animal a1 = new Dog();
a1.eat();
成员方法：编译时 Animal 类中必须要有 eat 方法(可以是抽象方法)，执行时运行的是右边 Dog 中的 eat 方法

为什么成员变量和成员方法的访问不一样呢？

因为成员方法有重写，而成员变量没有

重写(Override)与重载(Overload)

重写(Override)

重写是子类对父类的允许访问的方法的实现进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。
在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

在上面的例子中可以看到，尽管 b 属于 Animal 类型，但是它运行的是 Dog 类的 move 方法。
这是由于在编译阶段，只是检查参数的引用类型。
然而在运行时，Java 虚拟机(JVM)指定对象的类型并且运行该对象的方法。
因此在上面的例子中，之所以能编译成功，是因为 Animal 类中存在 move 方法，然而运行时，运行的是特定对象的方法。
思考以下例子：

package com.polymorphism.entity;
public class OverrideOverload {
    public static void main(String args[]){
        Animal a = new Animal(); // Animal 对象
        Animal b = new Dog(); // Dog 对象
        a.move();   // 执行 Animal 类的方法
        b.move();   //执行 Dog 类的方法
//        b.bark();   //编译失败，是因为 Animal 类中不存在 bark 方法
        Dog d1 = new Dog();
        d1.bark();      //编译成功，是因为 Dog 类中存在 bark 方法
    }
}
class Animal{
    public void move(){
        System.out.println("动物可以移动");
    }
}
class Dog extends Animal{
    public void move(){
        System.out.println("狗可以跑和走");
    }
    public void bark(){
        System.out.println("狗可以吠叫");
    }
}

方法的重写规则

参数列表必须完全与被重写方法的相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。(public>默认>protected>private)
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
被访问控制符 private 修饰的方法不能被重写。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则:

被重载的方法必须改变参数列表(参数个数、参数顺序、参数类型不同都能造成重载)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

实例:

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
    public void test(int a){
        System.out.println("test2");
    }
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

打印：

test1
1
test2
test3
returntest3
test4
returntest4

重写与重载之间的区别

区别点	重载方法 overloading	重写方法 overriding
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

总结:

方法的重写(Overriding)和重载(Overloading)是 java 多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

方法重载是一个类中定义了多个方法名相同,而他们的参数不同,则称为方法的重载(Overloading)。
方法重写是在子类中存在方法与父类的方法的名字相同，而且参数的个数与类型一样，返回值也一样的方法,就称为重写(Overriding)。
方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现。

**_@_Override **
是伪代码,表示重写。(当然不写@Override 也可以)，不过写上有如下好处:
1、可以当注释用,方便阅读；
2、编译器可以给你验证@Override 下面的方法是否正确的重写父类方法，如果没有则报错。例如，你如果没写@Override，而你下面的方法名又写错了，这时你的编译器是可以编译通过的，因为编译器以为这个方法是你的子类中自己增加的方法。

多态特性

https://www.liaoxuefeng.com/wiki/1252599548343744/1260455778791232
小结：

子类可以覆写父类的方法（Override），覆写在子类中改变了父类方法的行为；
Java 的方法调用总是作用于运行期对象的实际类型，这种行为称为多态；
final修饰符有多种作用：
- final修饰的方法可以阻止被覆写；
- final修饰的 class 可以阻止被继承；
- final修饰的字段必须在创建对象时初始化，随后不可修改。

覆写（Override）

在继承关系中，子类如果定义了一个与父类方法签名完全相同的方法，被称为覆写（Override）。
例如，在Person类中，我们定义了run()方法：

class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

在子类Student中，覆写这个run()方法：

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

Override 和 Overload 不同的是，如果方法签名如果不同，就是 Overload，Overload 方法是一个新方法；如果方法签名相同，并且返回值也相同，就是Override。
注意：方法名相同，方法参数相同，但方法返回值不同，也是不同的方法。在 Java 程序中，出现这种情况，编译器会报错。

class Person {
    public void run() { … }
}
class Student extends Person {
    // 不是Override，因为参数不同:
    public void run(String s) { … }
    // 不是Override，因为返回值不同:
    public int run() { … }
}

加上@Override可以让编译器帮助检查是否进行了正确的覆写。希望进行覆写，但是不小心写错了方法签名，编译器会报错。

public class Main {
    public static void main(String[] args) {
    }
}
class Person {
    public void run() {}
}
public class Student extends Person {
    @Override // Compile error!
    public void run(String s) {}
}

但是@Override不是必需的。
在上一节中，我们已经知道，引用变量的声明类型可能与其实际类型不符，例如：

Person p = new Student();

现在，我们考虑一种情况，如果子类覆写了父类的方法：

public class Main {
    public static void main(String[] args) {
        Person p = new Student();
        p.run(); // 应该打印Person.run还是Student.run?
    }
}
class Person {
    public void run() {
        System.out.println("Person.run");
    }
}
class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

那么，一个实际类型为Student，引用类型为Person的变量，调用其run()方法，调用的是Person还是Student的run()方法？
运行一下上面的代码就可以知道，实际上调用的方法是Student的run()方法。因此可得出结论：
Java 的实例方法调用是基于运行时的实际类型的动态调用，而非变量的声明类型。
这个非常重要的特性在面向对象编程中称之为多态。它的英文拼写非常复杂：Polymorphic。

多态

多态是指，针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。例如：

Person p = new Student();
p.run(); // 无法确定运行时究竟调用哪个run()方法

有童鞋会问，从上面的代码一看就明白，肯定调用的是Student的run()方法啊。
但是，假设我们编写这样一个方法：

public void runTwice(Person p) {
    p.run();
    p.run();
}

它传入的参数类型是Person，我们是无法知道传入的参数实际类型究竟是Person，还是Student，还是Person的其他子类，因此，也无法确定调用的是不是Person类定义的run()方法。
所以，多态的特性就是，运行期才能动态决定调用的子类方法。对某个类型调用某个方法，执行的实际方法可能是某个子类的覆写方法。这种不确定性的方法调用，究竟有什么作用？
我们还是来举栗子。
假设我们定义一种收入，需要给它报税，那么先定义一个Income类：

class Income {
    protected double income;
    public double getTax() {
        return income * 0.1; // 税率10%
    }
}

对于工资收入，可以减去一个基数，那么我们可以从Income派生出SalaryIncome，并覆写getTax()：

class Salary extends Income {
    @Override
    public double getTax() {
        if (income <= 5000) {
            return 0;
        }
        return (income - 5000) * 0.2;
    }
}

如果你享受国务院特殊津贴，那么按照规定，可以全部免税：

class StateCouncilSpecialAllowance extends Income {
    @Override
    public double getTax() {
        return 0;
    }
}

现在，我们要编写一个报税的财务软件，对于一个人的所有收入进行报税，可以这么写：

public double totalTax(Income... incomes) {
    double total = 0;
    for (Income income: incomes) {
        total = total + income.getTax();
    }
    return total;
}

来试一下：

public class Main {
    public static void main(String[] args) {
        // 给一个有普通收入、工资收入和享受国务院特殊津贴的小伙伴算税:
        Income[] incomes = new Income[] {
            new Income(3000),
            new Salary(7500),
            new StateCouncilSpecialAllowance(15000)
        };
        System.out.println(totalTax(incomes));		//800
    }
    public static double totalTax(Income... incomes) {
        double total = 0;
        for (Income income: incomes) {
            total = total + income.getTax();
        }
        return total;
    }
}
class Income {
    protected double income;
    public Income(double income) {
        this.income = income;
    }
    public double getTax() {
        return income * 0.1; // 税率10%
    }
}
class Salary extends Income {
    public Salary(double income) {
        super(income);
    }
    @Override
    public double getTax() {
        if (income <= 5000) {
            return 0;
        }
        return (income - 5000) * 0.2;
    }
}
class StateCouncilSpecialAllowance extends Income {
    public StateCouncilSpecialAllowance(double income) {
        super(income);
    }
    @Override
    public double getTax() {
        return 0;
    }
}

观察totalTax()方法：利用多态，totalTax()方法只需要和Income打交道，它完全不需要知道Salary和StateCouncilSpecialAllowance的存在，就可以正确计算出总的税。如果我们要新增一种稿费收入，只需要从Income派生，然后正确覆写getTax()方法就可以。把新的类型传入totalTax()，不需要修改任何代码。
可见，多态具有一个非常强大的功能，就是允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。

覆写 Object 方法

因为所有的class最终都继承自Object，而Object定义了几个重要的方法：

toString()：把 instance 输出为String；
equals()：判断两个 instance 是否逻辑相等；
hashCode()：计算一个 instance 的哈希值。

在必要的情况下，我们可以覆写Object的这几个方法。例如：

class Person {
    ...
    // 显示更有意义的字符串:
    @Override
    public String toString() {
        return "Person:name=" + name;
    }
    // 比较是否相等:
    @Override
    public boolean equals(Object o) {
        // 当且仅当o为Person类型:
        if (o instanceof Person) {
            Person p = (Person) o;
            // 并且name字段相同时，返回true:
            return this.name.equals(p.name) && (this.age == p.age);
        }
        return false;
    }
    // 计算hash:
    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

调用 super-重写父类

在子类的覆写方法中，如果要调用父类的被覆写的方法，可以通过super来调用。例如：

class Person {
    protected String name;
    public String hello() {
        return "Hello, " + name;
    }
}
Student extends Person {
    @Override
    public String hello() {
        // 调用父类的hello()方法:
        return super.hello() + "!";
    }
}

final 不可变

继承可以允许子类覆写父类的方法。如果一个父类不允许子类对它的某个方法进行覆写，可以把该方法标记为final。用final修饰的方法不能被Override：

class Person {
    protected String name;
    public final String hello() {
        return "Hello, " + name;
    }
}
Student extends Person {
    // compile error: 不允许覆写
    @Override
    public String hello() {
    }
}

如果一个类不希望任何其他类继承自它，那么可以把这个类本身标记为final。用final修饰的类不能被继承：

final class Person {
    protected String name;
}
// compile error: 不允许继承自Person
Student extends Person {
}

对于一个类的实例字段，同样可以用final修饰。用final修饰的字段在初始化后不能被修改。例如：

class Person {
    public final String name = "Unamed";
}

对final字段重新赋值会报错：

Person p = new Person();
p.name = "New Name"; // compile error!

可以在构造方法中初始化 final 字段：

class Person {
    public final String name;
    public Person(String name) {
        this.name = name;
    }
}

这种方法更为常用，因为可以保证实例一旦创建，其final字段就不可修改。

练习：

参考：https://book.apeland.cn/details/126/

CoderXiong

http://bfd2018.github.io/2022/05/28/javase/2-java-mian-xiang-dui-xiang/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 CoderXiong !

JavaSE 面向对象

FastDFS

2022-05-28 分布式文件系统

JavaWeb alibaba

1、Java基础

2022-05-28 JavaSE

Java 基础

2、Java面向对象

类的组成

构造器函数

成员变量

局部变量

实例变量

类变量

方法

代码块

一、类与对象

定义类

类实例化对象

二、this 关键字

this()与 super()使用详解

三、构造方法

构造方法的重载

小练习

四、static 静态字段和静态方法

五、包和导包

六、修饰符

1）访问权限修饰符

2）状态修饰符

七、getter 和 setter

八、继承

1.继承小结

2.基本用法

继承树

protected

super

3.向上转型

4.向下转型

instanceof操作符

5.区分继承和组合

九、Java 多态

Java 多态特点

多态中成员访问特点

重写(Override)与重载(Overload)

重写(Override)

方法的重写规则

重载(Overload)

重写与重载之间的区别

总结:

多态特性

覆写（Override）

多态

覆写 Object 方法

调用 super-重写父类

final 不可变

练习：

你的赏识是我前进的动力

`instanceof`操作符