Java学习笔记

1，继承性

继承性：子类继承了父类之后，子类就获取了父类的属性和方法。

继承性的格式：

class A{
    public void eat(){
        System.out.println("吃饭");
    }
}


class B extends A{
    public void sleep(){
        System.out.println("睡觉");
    }

    public static void main(String[] args) {
        B b=new B();
        b.sleep();
        b.eat();
    }

}

在这段代码中，A是B的父类，所以B可以调用A中的eat（）方法，这就是继承性。

继承性的好处
1：减少了代码的冗余，提高了代码的复用性
2：便于功能的扩展
3：为之后的多态性的使用，提供了前提

Java中关于继承性的规定
1，一个类可以被多个子类继承
2，一个类只能有一个父类，单继承
3，子夫类是相对的概念
4，子类直接继承的父类为直接父类，间接继承的父类为间接父类
5，子类继承父类以后，就获取了直接父类以及所以直接父类中声明的属性和方法
 

注意：1，如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
           2，所以的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
           3，意味着，所以java类具有java.lang.Object类声明的功能

2，多态性

1，理解多态性：可以理解为一个事物的多种形态。
2，何为多态性：对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

3，多态的使用：虚拟方法调用
            有了对象的多态性以后，我们在编译期，只能调用父类中生明的方法，但在运行期，我们实际执行的时子类重写父类的方法。
            总结：编译看左边，运行看右边

4，多态性的使用前提：
a：类的继承关系
b：要有方法的重写

5，对象的多态性只适用于方法，不适用于属性
 

3，接口

1：接口使用interface来定义
2：java中，接口和类是并列的两个结构
3：如何定义接口：定义接口中的成员
        3.1：JDK7及以前：只能定义全局常量和抽象方法
            >全局常量：public static final的，但是，可以省略不写
            >抽象方法：public abstract的
以下是接口的使用：

interface A{
    int x=0;
}

class B{
    int x=1;
}

class C extends B implements A{
    public void pX(){
        System.out.println(super.x);
        System.out.println(A.x);
    }

    public static void main(String[] args) {
        new C().pX();
    }
}

在此代码中，类C不光使用了子父类，也使用了接口，可以看出，接口在一定程度上，也同样拥有继承性，但这种继承性，有一定的规范性，并且，在接口中，不能定义构造器，所以，这意味着接口不能够实例化

4：java开发中，接口通过让类去实现（implements）的方法来使用
     如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
     如果实现类没有覆盖接口中的所有抽象方法，则此实现类仍为抽象类

5：java类可以实现多个接口---->弥补了java单继承性的局限性
    格式：class AA extends BB implements CC，DD,EE {   }

6：接口与接口之间可以继承，而且可以多继承

7：接口的具体使用，体现多态性

8：接口，实际上可以看作是一种规范

4，代码块

类的成员之四，代码块（或初始化块）

1，代码块的作用：用来初始化类，对象
2，代码块如果没有修饰的话，只能用static
3，分类：静态代码块vs非静态代码块

4，静态代码块
    >内部可以有输出语句
    >随着类的加载而执行，而且只执行一次
    >作用：初始化类的信息
    >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
    >静态代码块的执行，优先于非静态代码块的执行
    >静态代码块内只能调用静态的属性，静态的方法，不能调用非静态的结构

5，非静态代码块
    >内部可以有输出语句
    >随着对象的创建而执行
    >每创建一个对象，就执行一次非静态代码块
    >作用：可以在创建对象时，对对象的属性进行初始化
    >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
    >非静态代码块内部可以调用静态的属性，静态的方法，或非静态的属性，非静态的方法

对属性可以赋值的位置：
1：默认初始化
2：显式初始化
3：构造器中初始化
4：有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值
5：在代码块中赋值

执行先后顺序：1->2/5->3->4

总结：由父及子，静态先行
 

5，Final关键字

final：最终的
1：final可以用来修饰的结构：类，方法，变量
2：final用来修饰一个类：此类不能被其他类继承
                比如说：String类，StringBuffer类

3：final用来修饰方法：表面此方法不可以被重写
                比如说：Object中getClass（）；

4：final用来修饰变量：此时的“变量”就称为是一个常量
                4.1：final修饰属性，可以考虑赋值的位置有：显式初始化，代码块中初始化，构造器中初始化
                4.2：final修饰局部变量，尤其是final修饰形参时，表面此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参，一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

static final：用来修饰属性，全局常量