Java入门(5)__继承 接口

继承

提高代码复用
让类与类之间产生了关系，提供了多态的前提

class ClassDemo4 {
    public static void main(String[] args){
        Dog2 d = new Dog2();
        d.color = "yellow";
        System.out.println(d.color);
    }
}

class Animal{
    String color;
    int height;
}

/*
* 继承 extends
* */

class Dog2 extends Animal{

}

super （也即是父类）

访问超类的构造函数
必须第一行代码
构造函数的第一行默认是super 或者是this

class ClassDemo4 {
    public static void main(String[] args){
        Dog2 d = new Dog2();
        d.color = "yellow";
        System.out.println(d.color);
    }
}

class Animal{
    String color;
    int height;

    public Animal(String color){
        this.color = color;
    }
}

/*
* 继承 extends
* */

class Dog2 extends Animal{
    //调用父类的构造方法
    super("white");
    String dogname;
}

class chongwu extends Dog2{
    String owner;
}

super.xxx

访问超类的成员。

函数覆盖 override

只有在发生继承的时候才发生重写
父类私有方法不可以重写
重写后可以用super.函数名

final 最终的

修饰类 方法 变量
修饰类 不让继承
修饰方法 不能覆盖了
修饰变量 不能即为常量 不能更改，只能赋值一次

内部类

定义在类内部的类
内部类可以在类成员位置上
编译时产生的类：外部类名$内部类名，例如Demo$Engine.class
内部类还可以在方法内定义
内部类访问局部变量时，不能对局部变量进行重新赋值
java8不要求对局部变量用final修饰

public class Demo {
    public static void main(String[] args){
        String color;
        int tires;
    }

    public void Run(){
        int key = 888;
        //内部类
        class Engine{
            public void fire(){
                System.out.print("key ready :" + key);
                System.out.print("fire...");

            }
        }
        Engine e = new Engine();
        e.fire();
        System.out.print("run...");
    }
}

抽象类 abstract

定义

只是用来继承，不能实例化

• 从多个事物中将共性的，本质的内容抽取

• 狼和狗都是犬科，犬科就是抽象出来的概念

  抽象类

• java可以定义没有方法体的方法，具体实现由子类完成 ，称为抽象类
• 包含抽象方法的类就是抽象类

抽象方法的由来
多个对象都具有相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法

例如:狼狗都有吼叫，可是吼叫的内容不同，所以抽象类只定义了吼叫的功能，但是并不明确吼叫的细节。

---

抽象方法

没有函数体的方法，必须使用abstract修饰
抽象方法必须在抽象类中

public class abstractDemo {
    public static void main(String[] args){
        Dogg d = new Dogg();
        d.cry();
    }
}

abstract class Animall{
    //抽象方法
    abstract public void cry();
}

class Dogg extends Animall{
    //实现抽象方法
    public void cry(){
        System.out.println("wangwang...");
    }
}

接口 interface

interface{}
实现多继承
降低耦合度(交互度)

public class interfaceDemo {
    public static void main(String[] args){
    WomenStart ws = new WomenStart();
    ws.white();
    }
}
//白借口
interface White{
    public void white();
}
//类实现借口
class WomenStart implements White{
    public void white(){
        System.out.print("白 ");
    }
}

---

多个接口

public class interfaceDemo {
    public static void main(String[] args){
    WomenStart ws = new WomenStart();
    ws.white();
    ws.rich();
    ws.beau();
    }
}
//白借口
interface White{
    public void white();
}
//rich接口
interface Rich{
    public void rich();
}
//Beau接口
interface Beau{
    public void beau();
}

//类实现借口
class WomenStart implements White,Rich,Beau{
    public void white(){
        System.out.print("白 ");
    }

    public void rich(){
        System.out.print("富");
    }

    public void beau(){
        System.out.print("美");
    }
}