一、封装性

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。（这里说的信息就是类中的属性和方法）

1.1、封装性的体现

想要通过代码体现封装性之前，需要先了解Java的访问控制修饰符

1.1.1、认识“访问控制修饰符”

Java 支持以下 4 种不同的访问权限：

特别记忆：private出了这个类就不能访问了，public哪里都可以

===============================================================================
访问控制修饰符			可以用来								备注
-------------------------------------------------------------------------------
什么都写  		修饰对象：类、接口、变量、方法。
private  		修饰对象：变量、方法。 				注意：不能修饰类（外部类）
public  		修饰对象：类、接口、变量、方法
protected 	 	修饰对象：变量、方法。 				注意：不能修饰类（外部类）
===============================================================================

1.1.2、封装性实例

public class Person {//使用public修饰类（说明：private和protected不能用来修饰类）
    private String name;//使用private修饰属性，该属性只能找该类内访问
    private int age;
    String address;//什么都不写，即不使用访问修饰符修饰该属性

    public String getName() {//使用public修饰方法
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

1.1.3、实际开发使用场景

场景1：私有化(private)类的属性，提供公共(public)的get和set方法，对此属性进行获取或修改;
场景2：将类中不需要对外暴露的方法，使用private修饰 ;
场景3：单例模式中构造器private的了，避免在类的外部创建实例。(放到static关键字后讲)

二、继承性

2.1、extends 关键字与类的继承格式

1、在 Java 中通过 extends 关键字实现一个类继承另外一个类

2、类的继承格式

class 父类 {
}
 
class 子类 extends 父类 {
}

2.2、Java只支持单继承

注意： Java 不支持多继承，但支持多重继承。

2.3、继承的特性

1. 子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法。而且会先执行父类的构造方法，然后再执行子类的构造方法。
2. 子类拥有父类非 private 的属性、方法。
3. 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
4. 子类可以用自己的方式实现父类的方法。
5. Java 的继承是单继承（一个儿子只有一个亲生父亲），但是可以多重继承（儿子继承父亲、父亲继承爷爷、爷爷继承曾祖父，所以儿子也间接继承曾祖父）。
6. 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

2.4、Object类

Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。

我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。

以下两种方式是等价的

//显式继承:
public class Human extends Object{

}
//隐式继承:
public class Human{

}

2.4.1、Object类的几个重要方法

2.4.1.1、getClass()方法

getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用
getName()方法可以取得类的名称。语法如下:

getClass().getname();

2.4.1.2、toString()方法

返回对象的字符串表示形式

2.4.1.3、equals() 方法

equals() 方法用于比较两个对象是否相等。

== 和 equals 的对比：
1、== 是一个比较运算符
a、既可以判断基本类型，又可以判断引用类型
b、如果判断基本类型 （注意几种基本数据类型），判断的是值是否相等
c、如果判断引用类型，判断的是地址是否相等
d、两个new出的类用== 判断肯定不相等，因为他们地址不同，判断对象的值是否相等用equals。

2、equals 是Object的方法
a、只能判断引用类型
b、默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。
c、可以通过在类中重写equals方法，来判断自定义类型的数据的值是否相等。
比较时先看是否重写了equals方法，重写了equals方法的是比较内容是否相等，自建类未重写equals方法则表示比较引用。

2.5、对象类型的转换

主要包括向上转型与向下转型操作（等号右边转向左边）

2.5.1、向上转型

进行向上转型，父类类型的对象可以引用子类类型的对象。
向上转型的过程中，父类的对象无法调用子类独有的属性或者方法。

class People {
}

class Teacher extends People {
}

public class Demo3 {
	public static void main(String[] args) {
		People tom = new Teacher();//父类的引用指向子类的对象
	}
}

父类的引用指向子类的对象

2.5.2、向下转型

要想实现向下转型，需要借助强制类型转换。

格式：
子类类型 子类对象 = (子类类型) 父类对象;

class Bird { }//鸟类

class Pigeon extends Bird { }//鸽子类继承鸟类

public class Demo4 {
	public static void main(String[] args) {
		Bird bird = new Pigeon();				// 步骤1：父类引用子类对象（某只鸽子是一只鸟）
		Pigeon pigeon = (Pigeon)bird;			// 步骤2：强制类型转换+向下转型（某只鸟是一只鸽子）
	}
}

注意：
(1)两个没有继承关系的对象不可以进行向上转型或者向下转型。
(2)父类对象可以强制转换为子类对象，但有一个前提：这个父类对象要先引用这个子类对象。

辅助记忆：向上转型或者向下转型，看的都是右边向左边转

2.6、instanceof关键字

作用：判断一个实例对象是否属于某个类,

格式： 对象 instanceof 类；
返回结果：true或false

class Animal{ }

class Dog extends Animal{ }

class People{ }

public class Test{
	public static void main(String args[]) {
		Animal a = new Animal(); 	// 动物对象
		Dog d = new Dog();			// 狗对象
		// 判断动物是否为狗的子类
		System.out.println(a instanceof Dog);
		// 判断狗是否为动物的子类
		System.out.println(d instanceof Animal);
		// 由于狗是否为人的子类
		System.out.println(d instanceof People);//报错：原因是这两个类没有继承关系
	}
}

//结果
false
true

2.7、Java 重写(Override)与重载(Overload)

Java 重写(Override)与重载(Overload)参考学习

1. 从字面上看，重写就是 重新写一遍的意思。重写是子类对父类的允许访问的方法重新写一遍，返回值和形参都不能改变。即外壳不变，核心重写！
2. 在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。

2.8、final关键字

final 意为 “最终的”。即不可以再改变了

final 可以用来修饰变量、方法、类。

2.8.1、final变量

使用 final 关键字修饰变量，表示该变量不能一经赋值，就不能再被修改：

一般将使用 final 关键字修饰变量使用全部大写形式表示

//定义一个final类型的变量PI
final double PI = 3.14;

2.8.2、final方法

使用 final 关键字修饰方法，表示该方法不能被子类重写：

public class Animal{
    public final void sleep(){
    }
}

public class Dog extends Animal{
    public final void sleep(){//报错：原因使用 final 关键字修饰方法，表示该方法不能被子类重写：

    }
}

同时一个定义为 private 的方法隐式被指定为 final 类型

2.8.3、final类

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承；

//示例
public final class Dog{ 
} 

如果将某个类设置为 final 类，则该类中的所有方法都被隐式设置为 final 方法，但是 final 类中的成员变量可以被定义为 final 或非 final 形式

三、多态

多态是方法的多态，属性没有多态

3.1、多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

注意：使用static、final、private修饰的方法不能实现多态

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.eat();
        System.out.println("*******************");
        //对象的多态性：父类的引用指向子类的对象
        Person p2 = new Man();
		Person p3 = new Woman();
        //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
        p2.eat();
        p2.walk();
        
        p3.eat();
        p3.walk();
    }
}

//运行结果
人：吃饭
*******************
男人多吃肉，长肌肉
男人霸气的走路
女人少吃，为了减肥
女人窈窕的走路

对象能执行哪些方法， 主要看对象左边的类型，和右边关系不大

3.2、开发中真实使用的场景

public class AnimalTest {
	 public static void main(String[] args) {
        AnimalTest test = new AnimalTest ();
        test.func(new Dog());
        System.out.println("===============");
        test.func(new Cat());
    }

	//实际开发会创建一个方法，通过判断传入的对象，调用相关的方法执行
    public void func(Animal animal){//Animal animal = new Dog();
        animal.eat();
        animal.shout();

        if(animal instanceof Dog){
            Dog d = (Dog)animal;//向下转型与多态的使用
            d.watchDoor();
        } else if (animal instanceof Cat) {
            Cat c = (Cat)animal;
            c.catchingMice();
        }
    }
}

//运行结果
汪！汪！汪！
狗看门
===============
猫吃鱼
喵！喵！喵！
猫抓老鼠

与君共享

👉👉👉👉👉最后，有兴趣的小伙伴可以点击下面链接，这里有我整理的完整Java学习博客内容，谢谢~ 🌹🌹🌹🌹🌹

《Java基础专栏完整学习》