JavaSE 面向对象（二）

面向对象 2
多态的存在有三个必要条件：
要有继承，要有重写，父类引用指向子类对象
Car c= new Bus（）；
向上转型 Car c= new Bus（）；多态的实现
向下转型 Bus b = (Bus) c; 方便调用子类本身的方法
final 关键字
修饰变量，方法，常量 类
修饰变量 变量变常量
修饰方法 方法不能重写
修饰类 类不能被继承
static final 可以定一个静态全局常量
抽象类的定义：
至少包含一个抽象方法的类
抽象类和抽象方法 都是通过abstatct 关键字修饰
子类继承抽象类必须重写所有的抽象方法，除非子类也是抽象类
抽象类可以继承普通类 抽象类可以继承抽象类
抽象类可以拥有自己的属性和方法和构造方法
抽象类 = 普通类 + 抽象方法
接口 ：interface
接口是抽象类的抽象 是一个完全抽象的类
接口中只有抽象方法和全局静态常量
接口的存在是为了让子类实现 implements
普通类继承抽象类 实现接口
java是单继承 多实现（特例 接口和接口之间是多继承关系）
抽象类可以实现接口
接口可以继承接口
接口和抽象类的区别：
抽象类拥有普通类的属性和方法 而接口只有抽象方法
接口 = 完全抽象（抽象类）

• 1.代码块 静态代码块 构造方法调用顺序

package com.sxt;

public class Primary extends Language{
    public Primary() {
        System.out.println("Primary的构造方法");
    }
    static {
        System.out.println("Primary的静态代码块");
    }
    {
        System.out.println("Primary的代码块");
    }
    public static void main(String[] args) {
        new Primary();
    }
}
package com.sxt;

public class Language extends Teacher{
    public Language() {
        System.out.println("Language的构造方法");
    }
    static {
        System.out.println("Language的静态代模块");
    }
    {
        System.out.println("Language的代码块");
    }
}

• 2.重写 重载

    public class Teacher extends Human{
        public void drink() {
            System.out.println(name+"喝奶");
        }
        public void run() {
            System.out.println(name+"跑步");
        }
}

        String name;
    //重写    
    public void drink() {
            System.out.println(name+"喝水");
        }
    //重载
        public void run (String name) {
            super.name = name;
            System.out.println(name+"跑步");
            
        }
            public void Poetey() {
            System.out.println("语文老师教诗经");
        }

>Animal父类
package com.sxt;

public class Animal {
    private int age;
    public Animal() {
        
    }
    public Animal(int age) {
        this.age = age;
    }
    public void introduce() {
        System.out.println("我今年"+age+"岁了");
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
>Fish子类
package com.sxt;

public class Fish extends Animal{
    private double weight;
    public Fish(int age,double weight) {
        super(age);
        this.weight = weight;
    }
    public void swimming() {
        System.out.println("游泳"+weight+"克");
    }
    public double getweight() {
        return weight;
    }
    public void setweight(double weight) {
        this.weight = weight;
    }
}
>Bird子类
package com.sxt;

public class Bird extends Animal{
        private String color;
        public Bird() {
            
        }
        public Bird(int age,String color) {
            super(age);
            this.color = color;
        }
        public void fly() {
            System.out.println("飞翔"+color+"色");
        }
        public String getColor() {
            return color;
        }
        public void setColor(String Color) {
            this.color = color;
        }
}
>Test类
package com.sxt;

public class Test {
    public static void main(String[] args) {
        Fish GoadFish = new Fish(5,666.9);
        GoadFish.introduce();
        GoadFish.swimming();
        Bird bird = new Bird(9,"Blue");
        bird.introduce();
        bird.fly();
    }
    
}

• 4. 内部类

 abstract class Ouper {
        
    //方法内部类
        class Inter {
            
        }
        public abstract void run();
        //静态内部类
        static class eat {
            void chi() {
            System.out.println("吃金科");
        }
            }
        //局部内部类
        public void fly() {
            class iinter{
                public void ffly() {
                    System.out.println("飞飞飞");
                }
            }
            System.out.println("飞");
        }
        public static void main(String[] args) {
            //匿名内部类
            //创建匿名内部类对象
                                Ouper o = new Ouper() {
                public void run() {
                    System.out.println("跑");
                }
            };
            o.run();
        }
    }