面向对象编程基础-优快云博客

知识点总结

继承

继承的实现

继承的限制

不允许多重继承，允许多层继承
私有操作隐式继承
显式继承，比如public方法，子类可以直接使用
隐式继承，比如private属性，子类确实继承了过来，但并不能直接访问。
子类对象构造前调用父类构造（如果子类构造中没有显示说明调用父类哪一个构造方法，那么默认使用无参构造。如果父类不提供无参构造，则显示说明（super（title）；）或者编译错误。）

class Father {
    private String str;
    public Father() {
        System.out.println("父类无参");
    }
    public Father(String str) {
        this.str = str;
        System.out.println("父类有参");
    }
}
class Son extends Father {
    public Son(String str) {
        //super(str);
        System.out.println("子类有参"); 
    }
}
public class Demo {
    public static void main(String args[]) {
        Father f = new Son("HELLO");
    }
}

覆写

方法的覆写

覆写代码执行结果分析要素
- 实例化的哪个类
- 这个实例化的类里面调用的方法是否被覆写过
- 没被覆写调用的是父类
子类覆写方法的访问权限不能比父类更严格
- 父类方法用private声明，子类不能覆写
子类调用父类被覆写的方法，可以用super.方法（）来访问

属性的覆写

属性不封装，子类定义相同名称的属性

this和super

this	super
调用本类构造，方法，属性	调用父类构造，方法，属性
先查找本类中是否有指定的调用结构，如果有直接调用，没有调用父类定义	直接调用父类操作
表示本类当前对象

final

fianl称为终结器，可以定义类，方法，属性

使用final定义的类不能有子类
使用final定义的方法不能被子类覆写
使用final定义的变量就是常量

final class A {
}
public final void print() {
}
final double PI = 3.14;
public static final String MSG = "HELLO";//全局常量

多态

方法的多态：重载，覆写

对象的多态：向上转型，向下转型

重载
- 同一个方法名称，根据不同的参数类型和个数完成不同的功能
覆写
- 同一个方法，根据实例化的子类对象不同完成不同的功能
向上转型
- 子类对象变为父类对象（自动转换）
- 格式：父类父类对象 = 子类实例
- 用途：参数的统一
- 通过子类实例化的父类对象能调用的方法只能是父类中定义过的方法
向下转型
- 父类对象变为子类对象（强制转换）
- 格式：子类子类对象 = （子类）父类实例
- 用途：调用子类特殊方法
- ？？父类对象要调用实例化它的子类中的特殊方法

抽象类

基础

作用：从语法上明确定义子类需要覆写的方法。
定义：抽象类 = 普通类 + 抽象方法
抽象方法： abstract定义 + 没有方法体
抽象类： abstract声明 + 有抽象方法
使用抽象类：
- 抽象类必须有子类
- 强制子类覆写
- 通过子类实例化向上转型完成抽象类实例化

限制

抽象类中可以定义内部的抽象类，子类也可以定义内部类来继承抽象内部类

//定义抽象类的内部类
abstract class A {
    abstract class B {
        public abstract void print();
    }
}
class X extends A {
    public void print() {
        System.out.println("HELLO");
    }
    class Y extends B {//不同于其他必须，这个（定义内部抽象类的子类）是非必须的
        public void print() {

        }
    }
}

外部抽象类不允许使用static声明
内部抽象类允许使用static声明，声明后相当于一个外部抽象类，继承的时候用“外部类.内部类”表示类名称

//static定义的内部抽象类为外部类
abstract class A {
    static abstract class B {
        public abstract void print();
    }
}
class X extends A.B {
    public void print() {
        System.out.println("HELLO");
    }
}
public class Demo {
    public static void main(String args[]) {
        A.B ab = new X();
        ab.print();
    }
}

隐藏抽象类子类

abstract class A {
    public abstract void print();
    private static class B extends A {
        public void print() {
            System.out.println("WORLD");
        }
    }
    public static A getInstance() {
        return new B();
    }
}
public class Demo {
    public static void main(String args[]) {
        A a = A.getInstance();
        a.print();
    }
}

范例

class A {
    public void fun() {
        this.print();
    }
    public void print() {
        System.out.println("A");
    }
}
class B extends A{
    public void print() {
        System.out.println("B");
    }
}
public class Demo {
    public static void main(String args[]) {
        B b = new B();
        b.fun();
    }
}