继承

在此之前，我要写一个比较重要的一点，在JAVA核心教程和head of JAVA中都提到的，单例设计模式，它的好处就是可以保证一个类在内存中的对象唯一性。。单例设计模式又可以分为懒汉式和饿汉式两种，前者是在类加载到方法区的时候直接生成一个对象，饿汉式是在需要的时候再创建一个对象。
所谓单例，就是这个类能且仅能初始化一个实例对象。怎么去实现呢？那就是阻止类以外的地方去创建对象，我在类中就直接创建好对象。private构造器就可以使得类外无法创建对象，然后通过new 在本类中创建一个本类对象，定义一个公有的方法，将创建的对象返回。

/**
懒汉式
@author Jason c
@version 1.0 
*/
class TestObject2
{
    private static TestObject2 instance;
    private TestObject2(){}
    public static TestObject2 getInstance()
    {
        if(instance==null)
            instance=new TestObject2();
        return instance;
        
    }
}
/*
饿汉式 
*/
class single2
{
    private static single2 instance=new single2();
    private single2() {}
    public static single2 getInstance()
    {
        return instance;
    }
}

---

如何实现继承呢？

java提供了关键字：extends
格式：class 子类 extends 父类{}
好处：A.提高了代码的复用性，提高了代码的可维护性，让类与类之间产生了关系，从而为多态提供了前提
类和类之前产生关系，其实也是继承的弊端：类和类之前的耦合性增强了

开发的原则：低耦合，高内聚
耦合：类与类之前的关系
内聚：就是自己完成某件事的能力
java不支持多继承，单支持多级继承

---

继承的注意事项：

子类只能继承父类所有非私有的成员（成员变量和成员方法）
子类不能继承父类的构造方法，但是可以通过“super”关键字去访问父类的构造方法
不能因为部分功能而去继承
什么时候使用继承？
继承其实体现的是一种关系，"is a"
只要符合这种逻辑关系，就可以使用继承

---

继承中，成员变量之间的关系

在子类方法中访问一个变量的查找顺序
1.在子类方法的局部范围找，有就使用
2.在子类的成员范围找，有就使用
3.在父类的成员范围找，有就使用
4.如果还找不到，报错

---

this和super的区别?

分别是什么呢?
this代表本类对应的引用。
super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)
怎么用呢?
A:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
B:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
C:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法

---

继承中构造方法的关系

子类中所有的构造方法都会访问父类的无参构造方法 因为子类会继承父类的数据，可能还会使用父类的数据，所以子类初始化之前，一定要完成父类数据的初始化（默认有一句super();）
子类每一个构造方法的第一条语句默认都是：super();
如果父类中只有一个有参的构造方法，在子类的构造方法必须调用，而且是子类的构造方法第一句话必须是调用父类的有参构造方法，否则编译器会提示错误的。如果父类中有无参的构造方法，没有写的话，会自动调用的，也就不会报错。
**注意：super(...) 其中，"..."是需要载入的参数，即父类的有参构造函数的参数值，并非参数的变量名。

---

如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?
报错。
如何解决呢?
A:在父类中加一个无参构造方法
B:通过使用super关键字去显示的调用父类的带参构造方法
C:子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。

注意事项：

this(...)或者super(...)必须出现在第一条语句上。
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。
子类初始化之前先初始化父类

---

方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：
本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：
先找子类本身，再找父类。

方法重写的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。

案例：
A:定义一个手机类。
B:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。
按照我们基本的设计，我们把代码给写出来了。
但是呢?我们又发现新手机应该是手机，所以，它应该继承自手机。
其实这个时候的设计，并不是最好的。
因为手机打电话功能，是手机本身就具备的最基本的功能。
所以，我的新手机是不用在提供这个功能的。
但是，这个时候，打电话功能就没有了。这个不好。
最终，还是加上这个功能。由于它继承了手机类，所以，我们就直接使用父类的功能即可。
那么，如何使用父类的功能呢?通过super关键字调用

方法重写的注意事项：

父类的私有方法不可以被重写
子类重写父类方法的时候，权限不可以更低，假如父类方法是public，子类重写后不可以变成private
类静态方法，子类也必须静态方法

final关键字

继承的代码体现
由于继承中方法有一个现象：方法重写
所以，父类的功能，就会被子类给覆盖掉
有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。
这个时候，针对这种情况，Java就提供了一个关键字：final
final:顾名思义，最终的意思，常见的是它可以修饰类
当final修饰局部变量的时候，变量值无法改变
因此当局部变量为一般数据类型的时候，局部变量==常量（值不变）
当局部变量为引用数据类型的时候，局部变量==常量（值不变），此时的值是地址值，引用数据类型本身就是引用一个地址值，地址指向对象。

---

多态

多态是同一个对象，在不同时刻表现出来的不同状态。

多态的前提：

    1.要有继承关系
    2.要有方法重写
            其实没有也是可以的，但是如果没有这个就没有意义。
    3.要有父类引用指向子类对象。

多态中的成员访问特点：

    1.成员变量
            编译看左边，运行看左边。 
    2.构造方法
            创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
    3.成员方法
            编译看左边，运行看右边。 （因为方法被覆盖了）
    4.静态方法
            编译看左边，运行看左边。 
            静态和类相关，算不上重写，所以还是左边的
    结论：由于成员方法存在方法重写，所以它运行看右边，其他都是看左边

    解析：
    先看代码：

class Cat extends animals
{
    int num=1;  
}

class Dog extends animals
{
    int num=2;
    int num2=3; 
    public void Test ()
    {
        System.out.println(num);
    }
}
class animals
{
    int num=3;  
}
public class Test {
    public static void main(String[] args)
    {
        Dog D= new Dog();//创建一个Dog类的实例对象和Dog类的引用变量D，D指向Dog的实例对象
        animals a=D;//创建父类的引用变量a,指向引用变量D；
        System.out.println(a.num2)//测试此时引用变量a是否可以获得子类的成员变量num2
                a.Test();   //测试此时引用变量a是否可以获得子类的方法Test()

    }
}

运行结果是，报错，animals类中不含有Test()方法和成员变量num2。
总结，当引用变量为父类，指向子类的实例对象的时候，此时父类的引用变量就像是遥控器，上面的按键的功能只有父类拥有的，其他的“按不到”。

多态

那么，如果此时我想使用子类的特有功能怎么办？
Dog D2=a?
一定会报错
因为向下转型必须要通过强制类型转换，因为其实它还是Dog对象，只是被声明为animals类型。格式是Dog D2=（Dog）a，这样就不会报错

---

一个非常经典的多态小程序

多态的问题理解：
    class 孔子爹 {
        public int age = 40;
        
        public void teach() {
            System.out.println("讲解JavaSE");
        }
    }
    
    class 孔子 extends 孔子爹 {
        public int age = 20;
        
        public void teach() {
            System.out.println("讲解论语");
        }
        
        public void playGame() {
            System.out.println("英雄联盟");
        }
    }
    
    //Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
    //但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
    //然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
    //向上转型
    孔子爹 k爹 = new 孔子();
    //到人家那里去了
    System.out.println(k爹.age); //40
    k爹.teach(); //讲解论语
    //k爹.playGame(); //这是儿子才能做的
    
    
    //讲完了，下班回家了
    //脱下爹的装备，换上自己的装备
    //向下转型
    孔子 k = (孔子) k爹; 
    System.out.println(k.age); //20
    k.teach(); //讲解论语
    k.playGame(); //英雄联盟

不管怎么样，程序的入口只能是main，因此在类加载后，
应从public static void main(String[] args)开始顺序执行。

多态的内存图解
多态对象变换的内存图解