面向对象---继承

第一：类与类之间一定要有所属关系才可以继承。不要获取功能而继承

对于子父类的函数：

　　子类出现和父类一模一样的函数时，调用子函数，父类就想被覆盖一样，就是重写

　　对于重写来说，必须保证子类的权限大于父类

　　重载：只是看同名函数的参数列表；重写：子父类方法要一模一样，包括返回值。

对于子父类的构造函数：

　　子类的构造函数默认第一行有一个隐含的super语言，子类就直接获取了父类中的内容；主要为了初始化

　　super语句一定在子类构造函数的第一行

如果父类中没有空参数的构造函数，子类必须手动通过super语句形式，指定要访问父类中的构造函数

父类也有super语句，是object类

final关键字

　　对封装是一个挑战

　　为了避免被继承，被子类复写，所以final修饰的不可以被继承

　　因为是最终方法，所以不能被复写

　　对于修饰变量，只能赋值一次，对成员，局部都可以修饰

作用：

　　主要描述事物是一个固定的，为了增强阅读星，就起一个名字，用final修饰

作为常量，多个单词，最好用下划线连接起来，比较好阅读

抽象类

　　就是描述一些看不懂的东西，然后要由子类去完成，相当于强迫去完成，即“复写”

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。（这种情况比较少见）

练习：

class Employee
{
    private String name;
    private String id;
    private String pay;

    //进行初始化
    Employee(String name,String id,String pay){
        this.name=name;
        this.id=id;
        this.pay=pay;
    }

    public abstract void work();  //由于一个公司，每一个人的工作内容都不同，就把工作定义成一个抽象的类，再到每一个子类中自行定义工作的内容
}

class Manager extends Employee
{
    private int bonus;

    //进行初始化
    Employee(String name,String id,String pay,int bonus){
        super(name,id,pay);  //直接调用父类的就行了
        this.bonus=bonus;
    }
    public void work()
    {
        System.out.println("manager work"); 
    }
}

class Pro extends Employee
{
    Employee(String name,String id,String pay){
        super(name,id,pay);
    }
    public void work()
    {
        System.out.println("Pro work");   //这就是抽取出来的，自行定义子类的工作内容
    }
}

View Code

接口：

　　是一个特殊的抽象类，并且不可以创建对象，因为有抽象方法

　　定义一个抽象方法，到子类中去实例化

　　接口与接口之间可以继承，并且多继承

　　继承类时，还可以多实现

　　并且，接口中的成员都是public

interface Inter{
    public static final int NUM=3;
    public abstract void show  (); //因为没有方法主体，就可以多实现，
}

interface  InterA
{
    public abstract void method();
}

class Demo
{
    public void function();
}

class Test extends Demo implements Inter,InterA   //再继承一个类的同时，还可进行多实现
{
    public void show(){};  //要建立对象就要覆盖一个方法
    public void method(){};
}

//接口与接口之间，是继承关系，还可以多继承
interface A
{
    void methodA();
    int show();
}
interface B //extends A
{
    void methodB();
    boolean show();
}
interface C extends B,A  //多继承
{
    void methodC();
}
interface D implements C
{
    public void methodA(){};  
    public void methodB(){};
    public void methodC(){};  //继承了三个，就要实现三个方法
    public int show(){};
    public boolean show(){};  //这样不行，在D中，不知道是Int还是boolean
}

class InterfaceDemo
{
    public static void main(String[] args) {
        Test t=new Test();
        System.out.println(t.NUM);  //对象也可以调用
        System.out.println(Test.NUM);  //方法也可以调用
        System.out.println(Inter.NUM);  //接口也可以调用，接口也是一种类
    }
}

View Code

猜你喜欢