面向对象3

面向对象3

面向对象特征

面向对象语言的三大特征：封装、继承、多态

封装

将类的某些信息隐藏起来（使用访问权限修饰符来完成），使外部无法直接对其进行访问；

通过一个特定的方法来隐藏信息进行访问，便于控制。

设计模式：解决某一类问题的解决方案。

单例模式：让一个类在一个程序中只能创建一个对象

public class WindowDemo {
    //将构造方法设置为私有权限，在其他类中不能随便使用
    private static WindowDemo windowDemo=null;
    private WindowDemo(){

    }
    //向外界提供方法，获取唯一对象
    public static WindowDemo getWindow(){
        //控制对象生成的数量
        if(windowDemo == null){
            windowDemo = new WindowDemo();
        }
        return windowDemo;
    }
}

继承

子类（派生类）继承父类（基类）；

在子类中可以有扩展的子类特有的属性和方法；

作用：实现代码重用，提升程序的扩展性；

一个类只能直接继承一个父类，继承后子类就可以访问父类中的非私有属性和非私有方法；

当一个类没有显示的继承某个类，则这个类就默认继承Object类，Object类是所有类的基类。

使用继承的情况

两者是：什么是什么（is-a关系）的关系。

继承的格式

使用extends关键字

[访问权限修饰符] [修饰符] 子类名 extends 父类名{ }

继承的传递性

C继承B，B继承A，那么C就具有B、A类中的非私有属性和非私有方法。

继承中的构造方法

在创建子类对象后，调用构造方法时，从上向下的调用，先初始化父类信息；

使用super()在子类构造方法的第一行默认执行，调用父类无参构造方法，super()必须写在第一行。

super关键字

super关键字作用：使用super关键字访问父类成员 。

用super.成员变量名来引用父类成员变量 ；

用super.方法名（参数列表）访问父类的方法；

用super.构造方法(参数列表)访问父类构造方法 ；

注意: super不是父类对象。在创建子类对象时，不会创建父类对象，只会将父类中的信息加载到子类对象中存储。

方法的重写

当父类的方法实现不能满足子类需求的时候，在子类中对父类中的方法进行重写（覆盖）。

注意：构造方法、静态方法不能重写，成员变量不存在重写。

具体语法

方法名相同；

参数列表、返回值相同；

访问权限修饰符等于或大于父类的权限。

@Override

这是Java中提供的一个注释标签，表示此方法是从父类重写过来的，就会对其进行语法验证。

抽象类

一个类中没有足够的信息来描述一个具体对象，这样的类就是抽象类；

抽象使用abstract修饰，抽象类中可能包含抽象方法也可能不要包含抽象方法。

/*抽象类只能做基类，
* 抽象类一般都位于体系结构的上层*/
public abstract class Person {
    /*在一些比较靠顶层的类，它的实现与子类大多数不同，此时没必要在顶层类实现，只需要声明功能即可*/
    public abstract void speak();//抽象方法,没有方法体
}
/*抽象类不能创建对象（因为其中包含抽象方法），其他功能与类相同*/
public class Chinese extends Person{
    @Override
    public void speak(){
        System.out.println("中国人说汉语");//方法的参数、返回值要和抽象类中的方法一样
    }
}

一个类继承了抽象类：重写抽象类中的所有抽象方法或把这个类声明为抽象类。

多态

同一种事物在不同时刻表现的不同状态；

条件

有继承关系（类继承类、类继承抽象类、类实现接口）；

有方法重写；

父类的引用指向子类。

public abstract class Animal {
    public abstract void eat();
    public void sleep(){
    }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("Dog类重写Animal类——狗吃骨头");
    }
}

public class Test {
    public static void main(String[] args) {
        /*编译期间 a.eat() a的类型是Animal类型，调用的是抽象方法eat()
        * 运行期间 a指向的是一个Dog对象，运行的是Dog中重写的eat()
       */
        Animal a = new Dog();
        a.eat();
        a.sleep();
    }
}
/*非静态成员变量：编译期间看左边，运行期间看右边
  静态方法：编译期间看左边，运行期间看左边
  成员变量：编译期间看左边，运行期间看左边*/

多态转型

优点：父类引用可以表示子类对象，提升程序的可扩展性；

多态缺点：父类不能调用子类特有的方法，需要进行多态转型。

public abstract class Animal {
    public abstract void eat();
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void play(){
        System.out.println("狗会玩");
    }
}

public class Cat extends Animal {
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();//自动转型（向上转型），子类类型自动上升为父类类型
        Test t = new Test();
        t.eat(dog);
        t.eat(cat);
    }
    public void eat(Animal animal){
        animal.eat();

        if(animal instanceof Dog){  //instanceof判断父类引用类型是不是指定类型
            Dog dog = (Dog)animal;//强制转型（向下转型），父类类型转为子类类型
            dog.play();
        }
    }
}

instanceof关键字

父类引用 instanceof 具体的子类类型

作用：判断父类引用实际表示的对象是不是指定类型

final关键字

修饰类：被修饰的类不能被其他类继承；

修饰属性：修饰后的属性为常量，创建时需要对其赋值，赋值后值不可改变；

修饰方法：该方法不能被重写。

public class Car {
    static final int count=10;//定义时为其赋值，之后值无法改变
    final int num;//在定义是未对齐赋值，则必须在构造方法中对其赋值

    public Car(int num) {
        this.num=10;
    }
}
public class BC extends Car{
    public BC(int num) {
        super(num);
        System.out.println(num);
        System.out.println(super.num);
    }

    public static void main(String[] args) {
        BC bc = new BC(20);
        System.out.println(bc.num);
    }
}

接口

接口：如USB接口，规范的定义（定义口的大小、数据的传输方式）。

接口类似于抽象类，用于顶层，指定规范（设计功能）。

一个类可以实现多个接口，但只能直接继承一个类；

一个接口可以继承多个接口。

声明格式：

[访问修饰符] interface 接口名称 [extends 接口名1,接口名2…]

public class Cat implements Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}
public interface Animal {
    int num = 10;//public static final int num = 10;
    void eat();//抽象方法
    public static void testStatic(){  //静态方法通过接口名调用
        System.out.println("testStatic");
    }
    public default void testDefault(){  //默认方法通过子类对象调用
        System.out.println("testDefault");
    }
}
public class Dog implements Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
}
public class Cat implements Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        Animal.testStatic();//testStatic
    }
    public void feedAnimal(Animal animal){
        animal.eat();
    }
}