继承，接口，抽象类

继承 接口 抽象类

 

一、继承     extends

    当你写一个类时，虽然这个类满足了某些功能但是你又想拓展它的功能，此时你就可以使用继承机制再写一个该类的子类，来完成你需要的功能。继承提高了代码的效率，避免了代码重写。

 

    子类继承父类的属性和方法，而父类的私有属性不能直接访问，而是通过setter或getter方法调用访问。

class Person{
    private String name;      //私有属性
    private ine age;              //私有属性
    public String getName(){
        return name;                          //取得name
    }
    public void setName(String name){
        this.name = name;                 //设置name
    }
    public int getAge(){
        return age;                              //取得age
    }
    public void setAge(int age){
        this.age = age;                         //设置age
    }
}

 

class Student extends Person{
    public void fun(){
//        System.out.println("父类中的name属性："+name);
//        System.out.println("父类中的age属性："+age);
//以上方法错误，无法访问
    }
}

 

class Student extends Person{
    public void fun(){
        System.out.println("父类中的name属性："+getName());
        System.out.println("父类中的age属性："+getAge()); 
//因为父类中的name，age属性是私有的，所以在继承的子类中
//不能直接使用，只能通过getter，setter方法调用
    }
}

 

  继承特点：

        1、java中类的继承只允许单继承而不许多重继承，但可以通过接口实现多重继承。

        2、允许多层继承，B继承了A，C继承了B，则A与C同样存在继承关系。
           

方法重写
        保持方法的定义不变，但方法体内部实现不同。
  

 注意！子类中覆写的方法不能拥有比父类方法更加严格的访问权限。方法默认的访问权限是default，访问权限具体如下:

	同一个类	同一个包	不同包的子类	不同包的非子类
private	Y
default	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

 

 

 

 

 

 

 

 

 

思考将父类中的一个方法定义成private，子类覆写时声明为default即默认，这还叫做覆写吗？

class Person{
    private void print(){                                  //private访问权限
        System.out.println("Person-->void print(){}");
    }
    public void fun(){
        this.print();                        //调用print方法
    }
}

classStudent extends Person{
    void print(){                                        //扩大权限
        System.out.println("Student-->void print(){}");
    }    
}

public class Test{
    public static void main(String[] args){
        new Student().fun();
    }
}

 运行结果是：

 Person-->void print(){}

 发现调用的是父类方法，说明子类没有覆写父类中的print方法，而是重新定义了新的方法。

 

 

二、抽象类       abstract

    java中有一类专门作为父类的抽象类，它的作用类似于模板，一个子类也只能继承一个抽象类。抽象类也不能直接创建对象。抽象类介于类和接口之间，可以有实现的也可以有未实现的方法。

规则：包含一个抽象方法的类是抽象类，抽象类和抽象方法用abstract声明，

      抽象方法不需要实现，子类(如果不是抽象类)必须重写父类的全部抽象方法。

 

抽象类中可以定义属性，普通方法，抽象方法，构造方法。其实抽象类除了有特殊的抽象方法、不能实例化对象外，与普通类是相同的，都可以定义普通类中的属性和方法。

abstract class A{
    public A(){
        System.out.print("A,抽象类中的构造方法");
    }
}

class B extends A{
    public B(){
        System.out.print("B,子类中的构造方法");
    }
}

public class Test{
    public static void main(String[] args){
        B b = new B();
    }
}

 其中的B类等同于：

 

class B extends A{
    public B(){
        super();
        System.out.println("B,子类中的构造方法");
    }
}

 运行结果是：

A，抽象类中的构造方法

B，子类中的构造方法

 

三、接口        interface定义，  implements实现

    接口是由全局常量和抽象方法组成的。

    方法前无论是否写了public限定符，都是public型的。

interface A{
    public static final String name = "张三";
                                      //定义全局常量，同 String name = "张三";
    public abstract viod study();            
                                      //定义抽象方法，同 void print();
    public abstract String getInfo();         
                                      //定义抽象方法，同 String getInfo();
}

 

由于接口中没有任何方法的具体事项，所以不能用接口创建对象。

接口的实现用implements，一个类可以实现多个接口。

 

类可以通过extends继承类，类可以通过implements实现接口，接口与接口之间也可以通过extends实现继承，且一个接口可以继承多个接口！
如果一个类要实现一个接口，就要全部实现这个接口和它的父接口中定义的方法。