Java019-1——面向对象的三大特性
一、封装性
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。（这里说的信息就是类中的属性和方法）
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、继承的特性
- 子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法。而且会
先执行父类的构造方法，然后再执行子类的构造方法。 - 子类拥有父类非 private 的属性、方法。
- 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
- Java 的继承是单继承（一个儿子只有一个亲生父亲），但是可以多重继承（儿子继承父亲、父亲继承爷爷、爷爷继承曾祖父，所以儿子也间接继承曾祖父）。
- 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
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)参考学习
- 从字面上看，重写就是 重新写一遍的意思。重写是子类对父类的允许访问的方法重新写一遍，返回值和形参都不能改变。即外壳不变，核心重写！
- 在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。
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基础专栏完整学习》