java学习笔记(3)基本概念之抽象类和接口

抽象类：
抽象：笼统，模糊，看不懂！不具体。

特点：
1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
    抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。
3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。
    否则，这个子类还是抽象类。


1，抽象类中有构造函数吗？
    有，用于给子类对象进行初始化。

2，抽象类可以不定义抽象方法吗？
    可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
    通常这个类中的方法有方法体，但是却没有内容。

    abstract class Demo
    {
        void show1()
        {}
        

        void show2()
        {}
    }

3，抽象关键字不可以和那些关键字共存?
    private 不行
    static    不行
    final    不行

4，抽象类和一般类的异同点。
    相同点：
        抽象类和一般类都是用来描述事物的，都在内部定了成员。
    不同：
        1，一般类有足够的信息描述事物。
           抽象类描述事物的信息有可能不足。
        2，一般类中不能定义抽象方法，只能定非抽象方法。
           抽象类中可定义抽象方法，同时也可以定义非抽象方法。
        3，一般类可以被实例化。
           抽象类不可以被实例化。


5，抽象类一定是个父类吗？
    是的。因为需要子类覆盖其方法后才可以对子类实例化。
    
    
    
    
    
    
子父类中的构造函数的特点。

在子类构造对象时，发现，访问子类构造函数时，父类也运行了。
为什么呢？
原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();

子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
    
            
为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，
要先看父类是如何对自己的内容进行初始化的。

所以子类在构造对象时，必须访问父类中的构造函数。
为什么完成这个必须的动作，就在子类的构造函数中加入了super()语句。

如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用
父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，
那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。
但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。


注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。



一个对象实例化过程：
Person p = new Person();
1，JVM会读取指定的路径下的Person.class文件，并加载进内存，
    并会先加载Person的父类(如果有直接的父类的情况下).
2，在堆内存中的开辟空间，分配地址。
3，并在对象空间中，对对象中的属性进行默认初始化。
4，调用对应的构造函数进行初始化。
5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6，父类初始化完毕后，在对子类的属性进行显示初始化。
7，在进行子类构造函数的特定初始化。
8，初始化完毕后，将地址值赋值给引用变量.



继承弊端：打破了封装性。

final关键字：
1，final是一个修饰符，可以修饰类，方法，变量。
2，final修饰的类不可以被继承。
3，final修饰的方法不可以被覆盖。
4，final修饰的变量是一个常量，只能赋值一次。
    为什么要用final修饰变量。其实在程序如果一个数据是固定的，
    那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。
    而且这个变量名称的值不能变化，所以加上final固定。

    写法规范：常量所有字母都大写，多个单词，中间用_连接。


/*
abstract class AbsDemo
{
    abstract void show1();
    abstract void show2();
}

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
另一种形式定义和表示，就是 接口 interface。
*/

//定义接口使用的关键字不是class，是interface.
/*
对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1，全局常量: public  static final

2，抽象方法。public abstract

由此得出结论，接口中的成员都是公共的权限.


*/
interface Demo
{
    public static final int NUM = 4;

    public abstract void show1();
    public abstract void show2();
}
//类与类之间是继承关系，类与接口直接是实现关系。
/*
接口不可以实例化。

只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则，这个子类就是一个抽象类。

*/


class DemoImpl implements /*实现*/Demo
{
    public void show1()
    {}

    public void show2()
    {
    
    }
}


/*
在java中不直接支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行改良，在java中变成了多实现。

一个类可以实现多个接口。

*/

interface A
{
    public void show();
}

interface Z
{
    public int add(int a,int b);
}




class Test implements A,Z//多实现
{
    
    public int add(int a,int b)
    {
        return a+b+3;    
    }
    /**/
    public void show(){}
    
}





/*
一个类在继承另一个类的同时，还可以实现多个接口。



*/
class Q
{
    public void method()
    {}
}

abstract class Test2 extends Q implements A,Z
{

}
/*
接口的出现避免了单继承的局限性。

*/


interface CC
{
    void show();
}
interface MM
{
    void method();
}

interface QQ extends  CC,MM//接口与接口之间是继承关系，而且接口可以多继承。
{
    void function();
}

class WW implements QQ
{
//覆盖3个方法。
    public void show(){}
    public void method(){}
    public void function(){}
}


class InterfaceDemo
{
    public static void main(String[] args)
    {

        Test t = new Test();
        t.show();

//        DemoImpl d = new DemoImpl();    
//        System.out.println(d.NUM);
//        System.out.println(DemoImpl.NUM);
//        System.out.println(Demo.NUM);
    }
}



抽象类和接口的异同点：

相同点：
    都是不断向上抽取而来的。


不同点：
    1，抽象类需要被继承，而且只能单继承。
       接口需要被实现，而且可以多实现。
    2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
       接口中只能定义抽象方法，必须由子类去实现。
    3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
       接口的实现是 like a 关系，在定义体系额外功能。

多态在代码中的体现：
    父类或者接口的引用指向其子类的对象。


多态的好处：
    提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：
    前期定义的内容不能使用(调用)后期子类的特有内容。

多态的前提：
    1，必须有关系，继承，实现。
    2，要有覆盖。
    
    
    
    
    
多态时，
成员的特点：
1，成员变量。
    编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。
    运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。
    简单说：编译和运行都参考等号的左边。哦了。
    作为了解。


2，成员函数(非静态)。
    编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。
    运行时：参考的是对象所属的类中是否有调用的函数。
    简单说：编译看左边，运行看右边。

    因为成员函数存在覆盖特性。


3，静态函数。
        编译时：参考引用型变量所属的类中的是否有调用的静态方法。
        运行时：参考引用型变量所属的类中的是否有调用的静态方法。
        简单说，编译和运行都看左边。

        其实对于静态方法，是不需要对象的。直接用类名调用即可。


内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。


一把用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。
这时就是还有的事物定义成内部类来描述。




内部类可以存放在局部位置上。
内部类在局部位置上只能访问局部中被final修饰的局部变量。


匿名内部类。就是内部类的简写格式。
    
    必须有前提：
    内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}