java 基础之语法关键词的使用

1.super和this的使用

　　1.1：super表示父类对象，this表示当前对象

　　1.2：super()或this(）必须放在构造方法中的第一行，因为系统没有在第一行发现this()或super()调用，就会自动加上super()

　　1.3：static中不能使用supe或this修饰，因为static 修饰的方法是属于类的,该方法的调用者可能是一个类,而不是对象

 

2.static的使用

　　2.1：static可以修饰内部类、成员、代码块、方法

　　　　2.1.1加载顺序：静态属性-静态代码块-非静态属性-构造方法

　　　　2.1.2特点：随着类的加载而加载，只加载一次

　　　　2.1.3：static中不能使用supe或this修饰，不能和abstract使用

　　2.2：含有静态方法的内部类必须是静态内部类

　　2.3：静态变量可以为 类变量（与对象无关），而 实例变量则属于一个特定的对象。

　　　　2.3.1：静态变量是 基本数据类型，这种情况下在类的外部不必创建该类的实例就可以直接使用

　　　　2.3.2：静态变量是一个 引用。由于静态变量是一个对象的引用，那么必须初始化这个对象之后才能将引用指向它。

　　2.4：静态代码块主要用于类的初始化。

　　　　特点：1.随着类的加载而执行；

　　　　　　   2.静态代码块只能定义在类里面，不能定义在方法里；

　　　　　　　3.静态代码块里的变量都是局部变量，只在块内有效；

   　　　　　　4. 静态代码块只能访问类的静态成员，而不允许访问实例成员

　　　　　　　5.一个类中可以定义多个静态代码块，按顺序执行。

　　2.5：静态方法：与 类变量（静态变量） 不同，方法（静态方法与实例方法）在内存中只有一份，无论该类有多少个实例，都共用一个方法。

　　　　特点：1.静态方法可以直接使用，而 实例方法必须在类实例化之后通过对象来调用；

　　　　　　　2.在外部调用静态方法时，可以使用“类名.方法名”或者“对象名.方法名”的形式。实例方法只能使用后面这种方式；

　　　　　　　3.静态方法只允许访问静态成员。而实例方法中可以访问静态成员和实例成员；

　　　　　　　4.4.静态方法中不能使用this（因为this是与实例相关的）；　

 　　　　下面这段代码的输出结果是什么？

public class Test extends Base{
 
    static{
        System.out.println("test static");
    }
     
    public Test(){
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new Test();
    }
}
 
class Base{
     
    static{
        System.out.println("base static");
    }
     
    public Base(){
        System.out.println("base constructor");
    }
}

base static
test static
base constructor
test constructor

在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。

这段代码的输出结果是什么
public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }
     
    public Test() {
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new MyClass();
    }
}
 
class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
}
 
 
class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }
     
    public MyClass() {
        System.out.println("myclass constructor");
    }
}

结果：
test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

解析：
首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器

 

3.final 的使用：

　　3.1：它可以修饰非抽象类、非抽象类成员方法和变量，不能和abstract一起使用。

　　3.2：特点：

　　　　3.2.1：final类不能被继承，没有子类，final类中的方法默认是final的。

　　　　3.2.2：final方法不能被子类的方法覆盖，但可以被继承。

　　　　3.2.3：final成员变量表示常量，只能被赋值一次，赋值后值不再改变。final空白,必须在初始化对象的时候赋初值 

　　　　3.2.4：final不能用于修饰构造方法。

　　　　3.2.5：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

 

4.abstract的使用：

　　4.1：可以修饰类和方法，不能修饰成员

　　4.2：特点：

　　　　4.2.1：不能与static 、final、private使用

　　　　4.2.2：抽象类中不一定包含抽象方法，但是包含抽象方法的类一定要被声明为抽象类。

　　　　4.2.3：抽象类中可以包含构造方法， 但是构造方法不能被声明为抽象。

　　4.3：抽象类与接口的区别：

　　　　4.3.1：一个类可以实现任意多个接口，但最多只能作为一个抽象类的子类。

　　　　4.3.2：抽象类中可以有一般方法,而接口中:所有的方法都是是抽象的。

　　　　　　　  抽象类中的修饰符可以为public、protected、无修饰符（表示包内可见），而接口只能是public、无修饰符

　　　　4.3.3：抽象类可以有构造方法，而接口不能

　　　　4.3.4：接口声明变量时必须被初始化

 

5.public、protect、private区别：

　　　　

 

6.class 表示类，interface表示接口，@interface表示注解，enum表示枚举，extends 表示继承，implements表示实现。

 

7.synchronized：同一对象访问临界资源

　　7.1：用来修饰代码块和方法，保证在同一时刻最多只有一个线程执行该段代码

　　7.2：加锁与解锁需要同一把锁。

　　7.3：同步代码块synchronized(锁对象){需要同步的代码...}形式将访问数据的代码锁住，在同步代码块中的内容同一时间内只能一个线程执行。

　　　　  方法锁：如：public synchronized void testSyn(){}。同步非静态方法使用this作为锁，静态方法使用的是类对象本身