Java的三大特征：继承、封装、多态

1.封装

我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外
部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性
用于表示内部状态。

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

1.封装的步骤

使用private 修饰需要封装的成员变量。
提供一个公开的方法设置或者访问私有的属性

设置通过set方法，命名格式： set属性名（） ; 属性的首字母要大写
访问通过get方法，命名格式： get属性名（） ; 属性的首字母要大写

package com.oop.Demo5;

//快捷键 alt+insert

public class Teacher {
    private String name;
    private int 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;
    }

    public Teacher() {
       setName("wda");
    }
}

在类中一般不会把数据直接暴露在外部的,而使用private(私有)关键字把数据隐藏起来

如果在类的外部需要访问这些私有属性,那么可以在类中提供对于的get和set方法,以便让用户在类的外部
可以间接的访问到私有属性

2.作用和意义

1.提高程序的安全性，保护数据。
2.隐藏代码的实现细节
3.统一用户的调用接口
4.提高系统的可维护性
5.便于调用者调用

良好的封装，便于修改内部代码，提高可维护性。
良好的封装，可进行数据完整性检测，保证数据的有效性。

3.方法重载

类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载
可以提供方法调用的灵活性。

public class Test{
	public void test(String str) {
	}
		public void test(int a) {
		}
}

方法重载必须满足以下条件

1.方法名必须相同
2.参数列表必须不同(参数的类型、个数、顺序的不同)
3.方法的返回值可以不同，也可以相同

在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表

2.继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

为什么需要继承？继承的作用？

第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。
第二好处：为了提高代码的复用性。

extands的意思是“扩展”。子类是父类的扩展。

【注】 JAVA中类只有单继承，没有多继承！接口可以多继承！

1.继承

1.继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

2.继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来
表示

3.子类和父类之间,从意义上讲应该具有"is a"的关系.

4.类和类之间的继承是单继承

5.父类中的属性和方法可以被子类继承

子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有
的修饰符(public protected default private)相关的。

例如 :
父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用

注：具体细则在修饰符部分详细说明

父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用
super关键字)。

注:具体细节在super关键字部分详细说明

2. Object类

java中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关
系。从API文档中,可以看到任何一个类最上层的父类都是Object。 (Object类本身除外)AnyClass is a
Object。

在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承
过来的方法。 (因为Object是所以类的父类)

例如:toString方法、 equals方法、 getClass方法等
注:Object类中的每一个方法之后都会使用到.

3. Super关键字

子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问
或调用父类中的属性和方法。

【super使用的注意的地方】
1 . 用super调用父类构造方法，必须是构造方法中的第一个语句。
2.super只能出现在子类的方法或者构造方法中。
3.super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

【super 和 this 的区别】

代表的事物不一样:
this：代表所属方法的调用者对象

super：代表父类对象的引用空间。

使用前提不一致：
this：在非继承的条件下也可以使用。

super：只能在继承的条件下才能使用。

调用构造方法：
this：调用本类的构造方法。

super：调用的父类的构造方法

package com.oop.Demo5;

public class Student extends Person{
    //ctrl+h 查看父类
    String name;
    int age;

    public void stduy() {
        System.out.println(this.name);
        System.out.println(super.name);

    }
    //无参构造，默认自动创建空构造
    public Student(){
        this.name="Wen";
    }
    //有参构造.一旦定义有参构造，无参就必须显示定义
    public Student(String name){
        this.name=name;
    }
}

4.方法重写

方法的重写（override）
1 . 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不
能被重写.
2.静态方法不能重写

父类的静态方法不能被子类重写为非静态方法 //编译出错
父类的非静态方法不能被子类重写为静态方法； //编译出错
子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上
重写了。

1 . 重写的语法
1 . 方法名必须相同
2.参数列表必须相同
3.访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
4.抛出异常类型的范围可以被缩小,但是不能被扩大
ClassNotFoundException ---> Exception
5.返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返
类型的子类型

注：一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。 (也就是大括
号中代码不一样)

为什么要重写？

子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需
要把方法进行重写

总结：

方法重写的时候，必须存在继承关系。

方法重写的时候，方法名和形式参数必须跟父类是一致的。

方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。 ( private < protected <
public， friendly < public )

方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。 ( 子类 < 父类 ) 数据类型没有
明确的上下级关系

方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

3.多态

1.认识多态

多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在
执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。

多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加
灵活的编程，提高系统的可扩展性。

允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方
式。

相同类域的不同对象,调用相同的方法,执行结果是不同的

一个对象的实际类型是确定的，但是这个对象所属的类型可能有很多种。

2.重写、重载和多态的关系

重载是编译时多态

调用重载的方法, 在编译期间就要确定调用的方法是谁, 如果不能确定则编译报错

重写是运行时多态

调用重写的方法, 在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用, 在运行
期间所指向的对象是谁, 这个引用指向哪个对象那么调用的就是哪个对象中的方法。 (java中的方法调用,
是运行时动态和对象绑定的)

3.多态的注意事项

1 . 多态是方法的多态，属性没有多态性。
2.编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是
如果两个没有关联的类进行强制转换，会报： ClassCastException。比如：本来是狗，我把它转成
猫。就会报这个异常。
3.多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

4.多态存在的条件

1 . 有继承关系
2.子类重写父类方法
3.父类引用指向子类对象

补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没
有办法表现出多态特性的（因为不能被重写）：
1.static方法，因为被static修饰的方法是属于类的，而不是属于实例的
2.final方法，因为被final修饰的方法无法被子类重写
3.private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被
protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个
不能被外部引用的方法，怎么能谈多态呢

5.方法绑定(method binding)

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑
定。

静态绑定：
在编译期完成，可以提高代码执行速度。

动态绑定：
通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也
是JAVA比C/C++速度慢的主要因素之一。 JAVA中除了final类、 final方、 static方法，所有方法都是JVM在
运行期才进行动态绑定的。
多态：如果编译时类型和运行时类型不一致，就会造成多态。

6.instanceof和类型转换

System.out.println(x instanceof Y) ;
该代码能否编译通过, 主要是看声明变量x的类型和Y是否存在子父类的关系. 有"子父类关"系就编译通过,
没有子父类关系就是编译报错.
之后学习到的接口类型和这个是有点区别的。

System.out.println(x instanceof Y) ;
输出结果是true还是false, 主要是看变量x所指向的对象实际类型是不是Y类型的"子类型".

类型转换

 A a = new A();
        a.say();
        //父类的引用指向了子类
        B b = new A();//子类重写了父类方法
        //子类继承父类,调用a方法，如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法,
        //如果重写了,那么调用的就是重写之后的方法。
        b.say();
        //调用子类独有的方法
        ((A) b).said();

【总结】
1 、父类引用可以指向子类对象，子类引用不能指向父类对象。
2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。
如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）father；
其中father前面的（Son）必须添加，进行强制转换。
4、 upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效
5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样
使代码变得简洁。体现了JAVA的抽象编程思想。

Java的三大特征：继承、封装、多态