面向对象（二）

继承

主要是代码的复用(设计中意义会更多)
继承使用关键字extends
Java的继承是全部继承，除构造函数以外

继承中，子父类的构造函数的问题
子类必须调用父类的构造函数（构造函数不被继承）如果没有写调用，那子类的构造函数默认调用父类无参数的构造函数。(该句默认就在子类构造函数的第一句）—–>super(); 如果要显示调用那么要用——>super(参数列表);而且该句必须在子类构造函数的第一句。

父类子类初始化顺序
- 先父类静态，然后子类静态(跟创建对象无关，只要用到类就会先加载其静态属性，并且只加载一次
- 父类的定义初始化，父类的构造函数
- 子类的定义初始化，子类的构造函数

方法的重写
- 父类中有一个方法，到子类有重新的实现
- 访问权限必须为非private，子类中还可以放大
- super.方法() 调用父类被重写的的方法（因为如果不重写，可以直接调用）
总结：super关键字 super(参数列表）——>调用父类的构造函数必须在子类构造函数的第一句。
super.函数——>在子类中重写父类的方法调用父类的该方法

动态binding
父类的引用可以引用子类的实例对象。
如果父类的引用了子类的实例
调用该方法时，如果方法构成了重写，那么调用子类的方法，否则调用父类的方法——>动态绑定（binding）

多态

对象转型：
对象向上转型： 父类 父类对象 = 子类实例；
对象向下转型：子类 子类对象= （子类）父类实例；

• 向上转型

//对象向上转型class A{    public void fun1(){        System.out.println("A--->public void fun1(){}");    }    public void fun2(){        this.fun1();    }}class B extends A{    public void fun1(){        System.out.println("B--->public void fun1(){}");    }    public void fun3(){        System.out.println("B--->public void fun3(){}");    }}class  PolDemo01{    public static void main(String[] args)     {                           B b = new B();                          A a = b;                //发生了向上的转型的关系，子类-->父类                a.fun1();                   //此方法被子类fu写过    }}

• 向下转型

//向下转型class A{    public void fun1(){        System.out.println("A-->public void fun1(){}");    }    public void fun2(){        this.fun1();    }}class B extends A{    public void fun1(){        System.out.println("B-->public void fun1(){}");    }    public void fun3(){        System.out.println("B-->public void fun3(){}");    }}class  PolDemo02{    public static void main(String[] args)     {        A a = new B();              //发生了向上转型的关系，子类->父类        B b = (B)a;             //此时发生了向下转型关系        b.fun1();                       //调用方法被覆写的方法        b.fun2();                   //调用父类的方法        b.fun3();                   //调用子类自己定义的方法    }}

使用多态的好处：

//使用多态实现class A{    public void fun1(){        System.out.println("A-->public void fun1(){}");    }    public void fun2(){        this.fun1();    }}class B extends A{    public void fun1(){        System.out.println("B-->public void fun1(){}");    }    public void fun3(){        System.out.println("B-->public void fun3(){}");    }}class C extends A{    public void fun1(){        System.out.println("C--->public void fun1(){}");        }    public void fun5(){        System.out.println("C--->public void fun5(){}");    }}public class PolDemo05 {    public static void main(String[] args)     {        fun(new B());        fun(new C());    }    /*    在fun()中使用了对象的多态性，所以可以接收任何的子类对象，    这样无论子类如何增加，fun()都不用做任何改变，    因为一旦发生对象的向上转型后，调用的方法一定是子类覆写的方法。    */    public static void fun(A a){        a.fun1();    }}

构造函数私有化——单例设计模式

//构造方法私有化public class SingleDemo02 {    public static void main(String[] args)     {        Singleton s1 = Singleton.getInstance();        Singleton s2= Singleton.getInstance();        Singleton s3 = Singleton.getInstance();        s1.print();        s2.print();        s3.print();    }}class Singleton{    private static Singleton instance = new Singleton();//在类的内部产生本类的实例化对象    private Singleton(){    }    public static Singleton getInstance()        {        return instance;        }    public void print()    {        System.out.println("hello world");    }}

在设计模式中将这样的设计称为单例设计模式，即无论程序怎么样运行，Singleton类永远只会有一个实例对象存在。

抽象类

抽象类的定义及使用规则如下

• 包含一个抽象类方法必须是抽象类
• 抽象类和抽象方法都要使用abstract关键字声明
• 抽象方法只需声明而不需要实现
• 抽象类必须被子继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。

abstract class  A{    public static final String FLAG ="CHINA";    private String name = "yuyu";    public String getName(){        return name;    }    public void setName(String name){        this.name=name;    }    public abstract void print();}class B extends A{    public void print(){        System.out.println("FLAG="+FLAG);        System.out.println("姓名="+super.getName());    }}public class AbstractDemo02{    public static void main(String[] args){        B b = new B();        b.print();    }}

实际上抽象类就比普通类多定义了一个抽象方法，除了 不能直接进行对象的实例化操作之外并没有任何的不同。

接口

接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，是由全局常量和公共的抽象方法所组成。
接口定义格式

interface 接口名称{    全局变量;    抽象方法;}

在接口的抽象方法必须定义为public访问权限，这是绝对不可改变的。

/*    interface 接口名称{        全局变量；        抽象方法；    }*/interface A{    public String AUTHOR="xxx";    public void print();    public String getInfo();}interface B{    public void say();}class X implements A,B{    public void say(){        System.out.println("hello world");    }    public String getInfo()    {        return "hello";    }    public void print(){        System.out.println("作者："+AUTHOR);    }}class  InterfaceDemo03{    public static void main(String[] args)     {        X x= new X();        x.say();        x.print();    }}

子类同时继承抽象类和实现接口

/*子类同时继承抽象类和实现接口*/interface A{    public String AUTHOR = "XXX";    public void print();    public String getInfo();}abstract class B{    public abstract void say();}class X extends B implements A{    public void say(){        System.out.println("HelloWorld");    }    public String getInfo(){        return "hello";    }    public void print(){System.out.println("作者"+AUTHOR);}}class  InterfaceDemo04{    public static void main(String[] args)     {        X x = new X();        x.say();        x.print();    }}