Java继承多态与异常

1. 面向对象：将功能封装进对象，强调具备了功能的对象。
2. 面向对象的特征：封装encapsulate，继承inheritance，多态polymorphic。
3. 类的成员变量是具有默认初始值的，对象类型的初始值为null。而局部变量没有默认初始值。
4. 只要是用new操作符定义的实体就会在堆内存中开辟一个新的空间，并且每一份对象中都有一份属于自己的属性。
5. 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。
6. 封装的好处：将变化隔离，便于使用，提高重用性，提高安全性。
7. private：将数据私有化，用于修饰成员变量和成员函数，私有化的成员只在本类中可以用。
8. 构造函数没有返回值，添加了返回值的构造函数就会变成普通函数方法。
9. 一个类没有定义过构造函数，则会默认有一个空参数的构造函数，但凡定义过构造函数，则这个默认的空参数的构造函数则不存在了。多个构造函数则是以重载方式存在。
10. this——>指代本类对象的引用，即当前对象的引用，是属于对象的。static修饰的变量是可以修改的。
11. static用于修饰成员变量和方法，属于类本身，随着类的加载而加载，优先于对象存在，被所有对象共享，被类直接调用，虽然可以通过类的对象调用static修饰的能够访问到的变量或者方法，但并不建议用对象调用。
12. 成员变量随着对象的创建消亡而同步变化，类变量则随着类的加载消亡而同步变化；成员变量存储在堆内存中，是对象的特有数据，类变量存储在方法区(共享数据区)的静态区，也叫对象的共享数据；静态方法只可访问静态成员，访问非静态的成员会报错。
13. 静态方法中不可以使用this，super，使用静态方法的时候，如果变量还没有建立，通过this访问调用方法的对象，发现对象是不存在的，于是不能成功，所以Java直接不能够进行这样的操作。
14. 静态代码块：随着类的加载而执行，而且只执行一次，用于给类中的静态变量进行初始化，只能给静态变量初始化。
15. 构造代码块：可以给所有对象进行初始化，包括静态变量。
16. 静态代码块与构造代码块的示例：

package heima.person.caizhanqi.basetest;
public class BaseJavaTest {
    static{
        a=3;
        System.out.println("静态代码块");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    {
        b=4;
        a=5;
        System.out.println("构造代码块");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static int a;
    private int b;
    public BaseJavaTest(){
        System.out.println("构造函数");
    }
    public void sss(){
        System.out.println(a+"-----------"+b);  
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new BaseJavaTest().sss();
    }
}

1. 调用顺序：静态代码块——>构造代码块——>构造函数。
2. 为了不让别人创建某各类的对象，可以将该类的构造函数私有化。
3. 文档注释：如果想把一个类进行文档化，该类必须是public；私有的方法不会在文档中体现，示例如下：

package heima.person.caizhanqi.basetest;
/**
 * 用本类来测试文档注释
 * @author 蔡占其
 * @version 1.0
 */
public class BaseJavaTest {
    /**
     * 第一个函数
     */
    public static void funOne(){
    }
    /**
     * 第二个函数
     * @return -1
     */
    public int funTwo(){
        return -1;
    }
    /**
     * 
     * @param a int参数一
     * @param b int参数二
     * @return 返回-3
     */
    public int funThree(int a,int b){
        return -3;
    }
    /**
     * main函数
     * @param args 传入一个变量数组
     */
    public static void main(String[] args) {
    }
}

.
20. 注释文档必须为/*—/格式，注释中间可以添加格式各样的参数，用来说明功能，而在命令行使用javadoc ——>后面跟的命令，如-author等则是针对类的。main函数也可以被注释文档，并被当做函数提取出来。
21. 类与类之间的继承关系，是is关系。
22. 重写：@override 子类覆盖父类的方法，调用时会先调用子类的方法。注意：父类中的私有方法不能被覆盖；父类为static的方法无法重写；重写时，子类的方法权限一定要大于或等于父类该方法的权限。
23. 重载：@overload 同一个类中的相同方法签名，不同的参数。
24. 在子类的构造方法中，默认的第一行有一个隐式的super()；会调用父类无参的构造方法，如果自己有写super(args);则会调用相应的父类的构造方法。
25. 子类在构造函数中调用自己的其余构造函数时，使用this(args);此语句必须在第一行。super(args);super也必须在第一行。
26. 一个类的对象实例化过程：JVM读取指定路径下*.class文件，加载进入内存，若有父类，则先加载父类；在内存中开辟空间，并分配地址；并在对象空间中，对对象的属性进行默认初始化；调用构造函数进行初始化，先调用父类的，之后再对子类的属性进行显示初始化；进行子类构造函数的特定初始化；初始化完毕，将地址值返回赋值给引用变量。
27. final：可修饰类，方法，变量。终极类不可被继承，终极方法不能被覆盖。常变量不可被修改，只可一次初始化。
28. 构造块可以对常变量进行初始化，也可在真正的第一个被调用的构造函数中进行初始化。
29. 抽象类：定义了没有方法体的方法，该方法的具体实现交由子类实现，该方法称为抽象方法，包含抽象方法的就是抽象类。注意：抽象类通过其子类实例化，而子类要覆盖实现所有的抽象方法，否则该子类也是抽象类。
30. 抽象关键字不可以和private,static,final共存。抽象类一定是父类。
31. 接口：当一个抽象类中的方法都是抽象的时候，就可以将该抽象类用另一种形式表示和定义，就是接口。
32. 接口中的成员修饰符：成员变量——>public+(static/final)，成员函数——>public abstract。接口对外是暴露的，是程序的扩展。
33. 抽象类与接口的异同点：相同：都是不断向上抽取而来的。不同点：抽象类是被继承，接口是被实现；抽象类中含有抽象跟非抽象的方法，接口只能定义抽象方法，必须由子类实现；抽象类的继承是is a关系，定义该体系的基本共性内容，接口的实现是like a关系。
34. 多态：父类型引用指向了子类对象，一个对象对应着不同的类型。体现：父类或接口的引用指向或者接收自己的子类对象。多态的存在提高了程序的可扩展性和后期可维护性。
多态示例：个人并不建议用子类指向父类发生强转的行为。

class Animal{
    public void eat(){
        System.out.println("动物吃");
    }
    public void sleep(){
        System.out.println("动物睡");
    }
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
    public void show(){
        System.out.println("狗表演");
    }
}
class Fish extends Animal{
    @Override
    public void eat() {
        System.out.println("鱼吃水草");
    }
}

.
36. instanceof：用于判断对象的具体类型，且只能用于引用数组类型的判断，通常在向下转型前用于健壮性的判断。
37. 对于非静态成员函数，编译时看左边，运行时看右边；对于静态成员函数，编译和运行时都看左边。
38. 内部类可以直接访问外部类中的成员，包括私有成员，而外部类则要通过建立内部类的对象来访问内部类的数据。内部类在成员位置上可以被private，static成员修饰符修饰，被static修饰的内部类只能访问外部类中的静态成员。如果内部类是静态的，则相当于一个外部类。当内部类是非静态的，则在使用内部类的时候，必须先具有外部类作为通道，而静态内部类不需要。内部类的只要具有静态的成员就必须将该内部类设置为静态的。
39. 内部类定义在函数中或称为局部，访问的外部类中的成员，外部类成员修饰符可以任意，而局部成员变量必须是final修饰的。
40. 匿名内部类示例：

interface d{
    void showT();
}
public class BaseJavaTest {
    private  int a = 4;
    void show(){
        final int b = 5;
        new d(){
            @Override
            public void showT() {
                System.out.println(b);
            }
        }.showT();
    }
    public static void main(String[] args) {
     BaseJavaTest a = new BaseJavaTest();
     a.show();
    }
}

.
41. 异常处理，throws与throw的区别：throws用在函数上，用于抛出异常类，可抛出多个，而throw则用在函数中，用于抛出异常对象。
42. Exception子类中，除RuntimeException体系外，其余异常在编译的时候就可以检测出来，自定义异常一般继承RuntimeException或Exception。
43. 异常抛出准则：如果子类覆盖了父类的方法，而父类的方法抛出了异常，那么子类方法只能抛出父类的异常或者该异常的子类。如果父类抛出多个异常，那么子类只能抛出父类异常的子集。如果父类的方法没有抛出异常，那么子类只能try-catch，不能抛。
44. Object是所有类的根类，具有所有类的共性。当一个对象与另一个对象比较时候，如果使用==，则默认比较是否指向同一个对象。Object类中的equals方法仅仅通过==来判断是否相等。所以最好对每个自定义的类都重写equals方法。
45. equals()方法的比较原则：当且仅当该equals方法参数不是null，两个变量的类型、内容都相等，则比较结果为true。
46. 对象的比较，重写equals方法：1.先用==判断是否相等；2.判断equals方法的参数是否为null，是返回false，因为当前对象不能为null，如果为null，则不能调用equals方法，否则会抛出java.lang.NullPointerException异常。
示例：equals方法重写：

    if (obj == null)
        return false;
    if (!(obj.getClass() == this.getClass()))
        return false;
    else {
        Demo d = (Demo)obj;
        return d.getNum() == this.num;
    }