面向对象之三大特征封装、基础、多态

特征一：封装

为什么要引入封装性？

​ 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

问题引入

​ 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。
这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。
但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有(private).
–>此时，针对于属性就体现了封装性。

封装性的体现

1. 将类的属性XXX私有化(private)，同时提供公共(public)的方法来获取(getXXX)和设置(setXXX)此属性的值（只在需要使用的时候调用方法修改使用，不改变声明时本身的值）
2. 不对外暴露的私有的方法
3. 单例模式（将构造器私有化）
4. 如果不希望类在包外被调用，可以将类设置为缺省（default，也就是什么也不写）的。

权限修饰符

1. 4种权限修饰符，分别为private、default、protected、public，权限大小按从小到大排序

2. 均可用来修饰类及类的内部结构：属性、方法、构造器、内部类

具体的修饰范围

特征二：继承

1.继承的好处

1. 减少了代码的冗余，提高了代码的复用性

2. 便于功能的扩展

3. 为之后多态性的使用，提供了前提

2.继承的格式

class A extends B{}

其中A可以称为：子类、派生类、subclass，B可以称为：父类、超类、基类、superclass

3.字类继承父类之后有什么不同

• 体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。

• 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。

• 子类和父类的关系，不同于子集和集合的关系。
• extends：延展、扩展

4.继承性的说明

1. 一个类可以被多个子类继承。
2. Java中类的单继承性：一个类只能有一个父类
3. 子父类是相对的概念。
4. 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
5. 子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法
   

Object类的理解

1. 如果我们没显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2. 所有的java类（除java.lang.Object类之外都直接或间接的继承于java.lang.Object类
3. 意味着，所有的java类具有java.lang.Object类声明的功能。

特征三：多态

理解

理解为一个事物的多种形态

何为多态性

对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

Person p = new Man();//Person即为父类，Man即为子类

多态性的使用：虚拟方法调用

有了对象多态性以后，我们在编译器，只能调用父类中声明的方法，但在运行期我们实际执行的是子类重写父类的方法。

总结：编译，看左边；运行，看右边。

对象的多态性，只适用于方法，不适用属性（编译运行都看左边）

使用前提

1. 类的继承关系
2. 方法的重写

方法(例子)

package DuoTai;
public class DuoTaiTest {
    public static void main(String[] args) {
        DuoTaiTest duoTaiTest = new DuoTaiTest();
      
        duoTaiTest.AnimalTest(new Dog());//创建子类Dog对象
        duoTaiTest.AnimalTest(new Cat());//创建子类Cat对象
    }
    public void  AnimalTest(Animal animal){//创建父类的变量animal来接收子类对象，相应的也会调用子类的方法
        animal.eat();
        animal.shout();
    }
}
class Animal{
    public void eat(){
        System.out.println("动物，吃东西");
    }
    public void shout(){
        System.out.println("动物，叫");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("小狗吃骨头");
    }
    public void shout(){
        System.out.println("小狗汪汪叫");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("猫咪吃鱼");
    }
    public void shout(){
        System.out.println("猫咪喵喵叫");
    }
}
/*输出结果为：

小狗吃骨头
小狗汪汪叫
猫咪吃鱼
猫咪喵喵叫

*/

属性(例子)

package DuoTai;

public class DuoTaiTest2 {
    public static void main(String[] args) {
        DuoTaiTest2 dd = new DuoTaiTest3();//多态：Test2的变量dd 指向 Test3的对象
        System.out.println(dd.id);
        //变量dd调用id，原则上来说应该调用的id为子类Test3的属性id，而输出结果显示调用的父类Test2的属性id
        //说明，多态只用于方法，不适用于属性（编译运行都只看左边，也即父类的属性）
    }
    int id = 1001;
}
class DuoTaiTest3 extends DuoTaiTest2{//Test3类继承Test2类
    int id = 1002;
}

//输出结果为1001

方法属性(例子)

public class FieldMethodTest {
	public static void main(String[] args){
		Sub s = new Sub();
		System.out.println(s.count);//20
		s.display();//20
        
		Base b = s;//多态，向上转型，即Base b = new Sub();
		System.out.println(b == s);//true
		System.out.println(b.count);//10
		b.display();//20
		}
}
class Base {//父类
	int count = 10;
	public void display() {
		System.out.println(this.count);
	}
}
class Sub extends Base {//子类
	int count = 20;
	public void display() {
	System.out.println(this.count);
	}	
}

多态：向下转型

为什么使用：

​ 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法，而不能调用子类的。
​ 如何才能调用子类特的属性和方法？使用向下转型。

如何使用

​ 使用强制类型转换符：（）

注意点

1. 使用强转时，容易出现ClassCastException的异常

2. 为了避免这个异常，我们在向下转型之前，先进行instanceof的判断，

   一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

instanceof的使用

1. a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
2. 如果 a instanceof A 返回 true，则 a instanceof B也返回 true.其中，类B是类A的父类。
3. 要求a所属的类与类A必须是子类和父类的关系，否则编译错误。(a和A之间必须有关系)

例子

package DuoTai;
public class InstanceOfTest {
    public static void main(String[] args) {
        Person p1 = new Men();//Person类型的变量p1 指向 Men类的对象
        Men m1 =(Men)p1;//向下转换
        Woman w1 = (Woman)p1;
        m1.characteristic();//成功运行
        w1.career();//报错，因为变量p1只指向Men类的对象，并没有指向Woman类
        //可通过instanceof来改错     
        //if(p1 instanceof Woman){
        //    Woman w1 = (Woman)p1;
        //    w1.career();
        //}
        //或者 创建指向Woman类的p2变量
    }
}
class Person{
    public void id(){
        System.out.println("我是一个人");
    }
}
class Men extends Person{
    public void id(){//重写
        System.out.println("我是一个男人");
    }
    public void characteristic(){//特有的方法
        System.out.println("跑得更快，吃得更多，长得更壮");
    }
}
class Woman extends Person{
    public void id(){//重写
        System.out.println("我是一个女人");
    }
    public void career(){//特有的方法
        System.out.println("大部分老师都是女生");
    }
}

Object类的理解

1. 如果我们没显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2. 所有的java类（除java.lang.Object类之外都直接或间接的继承于java.lang.Object类
3. 意味着，所有的java类具有java.lang.Object类声明的功能。

UML图