OOP笔记3----面向对象三大特征

封装

1. 广义上的封装：定义方法是封装，定义类也是封装
2. 狭义上的封装：将类中属性封装
        --添加private访问权限修饰词，外界就不能直接访问属性了
        --然后提供属性有关的公有的getter/setter方法，用来操作这个被私有化的属性。

封装的目的

一个类中的某些属性，不希望直接暴露给外界，让外界直接进行操作。如果让外界直接对这个属性进行值的设置，有可能不符合逻辑。此时就需要将这个属性封装起来，不让外界直接访问。

单例设计模式

单例模式是一种常用的软件设计模式，属于创建型模式之一。它的目的是确保一个类只有一个实例，并提供一个全局访问点。

单例的饿汉模式

1.提供一个private权限的、静态的、当前类的属性，并在静态代码段中进行实例化。

2.构造方法私有化，杜绝从外界通过new的方式实例化对象的可能性。

3.提供一个public权限的静态方法，获取一个当前类的对象。

public class Person{

    //设计一个私有的、静态的、当前类的对象
    private static Person instance;

    static{
        instance = new Person();
    }
    
    //构造器私有化
    private Person(){}

    public static Person getInstance(){
        return instance;
    }
}

单例的懒汉模式

1.提供一个当前类的、静态的、private权限的属性
2.提供一个私有的构造器。避免外界直接调用构造器
3.提供一个公有的，静态的方法，来创建当前类的对象。

public class Student{
    //私有化的静态变量
    private static Student instance;
    //私有化构造器
    private Student(){}
    public static Student getInstance(){
        if(instance == null;
            instance = new Student();
        }
        return instance;
    }
}

继承

是面向对象最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

已有的类，叫父类；派生出来的新类，叫子类。

语法：

修饰词  class  子类名  extends  父类名{

        //子类的类体

}

继承的特点

1、Java只支持单继承，即一个类只能有一个父类；但是一个父类可以有多个子类。

2 、java支持多重继承，即一个类在继承自一个父类的同时，还可以被其他类继承。 可见继承具有传递性

3、子类继承了父类的所有成员变量和方法，包括私有的（只不过没有访问权限），当然也包括静态成员。

4、子类不会继承父类的构造方法，只能调用父类里的构造方法，并且一定至少有一个子类构造器调用了父类的构造器。

5 、子类在拥有父类的成员的基础上，还可以添加新成员。

继承中的构造器

1.默认调用的是父类中的无参构造器。如果父类中没有无参构造器，那么子类需要显示调用父类中的某一个有参构造器。

2.在子类的构造方法中，使用super(有参传参)调用父类中存在的构造方法，而且super(有参传参)必须放在首行首句的位置上。因此可知，super(有参传参)和this(有参传参)不能在一个构造器中共存。

继承中的方法重写

在子类中，对从父类继承到的方法进行重新的实现。 这个过程中，子类重写该方法，会覆盖掉继承自父类中的实现方法。

目的：

因为父类的方法逻辑不能满足子类的需求了，因此子类需要修改逻辑，即重写。

特点：
1.子类只能重写父类中存在的方法。
2.重写时，子类中的方法名和参数要与父类保持一致。
3.返回值类型：必须和父类方法的返回值类型相同，或者是其子类型。
4.访问权限：子类重写方法的访问权限必须大于等于父类方法的访问权限。

多态

多态：就是多种形态，多种状态的含义，在这里，指的是一个对象具有多种形态的特点。就是一个对象可以从一种类型转换为另外一种类型。有向上转型和向下转型两种形式

向上造型

1.父类型的变量引用子类型的对象；

2.向上转型肯定会成功，是一个隐式转换；

3.向上转型后的对象，将只能访问父类中的成员（编译期间，看变量类型）；

4.如果调用的是重写过的方法，那么调用的一定是重写方法（运行期间，看对象）；

5.在定义方法时，形式参数是父类型的变量。这样更加灵活，可以传任意子类型的对象

格式：

父类型   变量 =  new  子类型();

public class AnimalTest{
    public static void main(String[] args){
        Animal a = new Cat("白色",3);
        //调用方法
        a.noise();
        test1(a);
    }
    public static void test1(Animal animal){
        animal.noise();
    }
}

向下转型

1.父类型变量赋值给子类型的变量，需要强制转换，是一个显示转换；

2.可能会失败，失败的话，会报造型异常；

3.为了避免异常，可以使用instanceof来判断：变量指向的对象是否属于某一个类型；

4.目的：前提是父类型的变量引用子类型的对象。但是父类型的变量调用不了子类里独有的功能，已经不能满足需求。

格式：

子类型   变量名 = (子类型)父类型变量

public class AnimalTest2{
    public static void main(String[] args){
        Animal an = new Dog("黄色",8);
        an.noise();
        //调用一下对象的独有功能
        //编译期间看变量类型，没有该方法，只有向下转型
        Dog d = (Dog) an;
        d.LookHouse();
    }
}