面向对象（二）

继承

主要是代码的复用(设计中意义会更多)
继承使用关键字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();
    }
}