Java一些知识点

this的使用

1.this.成员变量(普通的成员变量非静态的，调用当前对象的成员变量)

2.this.成员方法(普通的成员方法非静态的，调用当前对象的成员方法)

3.this.（）（调用当前对象的构造方法）

super的使用

1.super.成员变量(访问父类的成员变量)

2.super.成员方法(访问父类的成员方法）

3.super.（）（调用父类的构造方法）

static

1.用static修饰成员变量，即如果给类中某个属性加上了static，则表示为类的成员变量，而非对象的成员变量，属于所有对象所共享

2.static修饰成员方法，则表示为类的静态成员方法

3.static修饰代码块，则表示为静态代码块，会在实例代码块、构造方法之前执行，且只执行一次

静态的成员变量和成员方法都不依赖于对象，通过类名.静态进行访问

注：

a.不要在静态方法里使用this

b.不要在静态方法中直接调用非静态方法

代码块

普通代码块：定义在方法内的代码块

实例代码块：定义在类的内部，与构造方法等方法同级，初始化实例的成员

静态代码块：给实例代码块加上static，初始化静态的成员，只执行一次

执行优先级：静态>实例>普通，父类>子类

class Student{
    private String name;//
    private int age;//
    private int id;//
    private static String school;//有static修饰,不再是对象的成员变量，而是类的成员变量

    public Student() {
        System.out.println("不带参数的构造方法");
    }
    public Student(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
    {
        this.name="wo";
        this.age=18;
        this.id=123;
        System.out.println("实例代码块:定义在类的内部，与构造方法等方法同级，初始化实例的成员");
    }
    static {
        school="xi'an";
        System.out.println("静态代码块:给实例代码块加上static，初始化静态的成员");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public static String getSchool() {
        return school;
    }

    public static void setSchool(String school) {
        Student.school = school;
    }
    public void eat(){
        System.out.println(this.name+"吃饭");
    }
    public void sleep(){
        {
            System.out.println("普通代码块");
        }
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student=new Student();
        System.out.println(Student.getSchool());
    }
}

实例内部类

1.获取实例内部类的对象

外部类名.内部类 变量=外部类对象的引用.new 内部类对象（）

2.在实例内部类当中，定义的成员变量不是静态的，如果定义只能是static final

3.实例内部类中，包含外部类的this，也包含自己的this

4.实例内部类对应的字节码文件：外部类$内部类.class

静态内部类

1.创建内部类对象：外部类名.内部类   变量=new 外部类名.内部类名（）

2.在内部类中只能访问外部类中的静态成员

3.成员内部类，经过编译之后会生成独立的字节码文件，命名格式为：外部类名称$内部类名称

class OuterClass{
    public static int data1=1;
    private int data2=2;
    public int data3=3;
    //实例内部类
    class InnerClass{
        public int data1=2;
        public int data4=4;
        private int data5=5;
        public static final int data6=6;//实例内部类中不能使用static修饰变量，如果要使用，只能用static final
        public void test(){
            System.out.println(OuterClass.this.data1);//外部类的data1
            System.out.println(this.data1);//实例内部类自己的data1
            System.out.println("InnerClass的test方法");
        }
    }
    //静态内部类
    static class InnerClass2{
        public void test(){
            test2();//只能访问外部类的静态成员
            System.out.println(OuterClass.data1);//外部类的data1，类成员变量
            //System.out.println(OuterClass.data2);//不能访问外部类的data2
            System.out.println("InnerClass2的test方法");
        }
    }
    public void test(){
        System.out.println("OuterClass的test方法");
    }
    public static void test2(){
        System.out.println("OuterClass的test2方法");
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        OuterClass outerClass=new OuterClass();
        OuterClass.InnerClass innerClass=outerClass.new InnerClass();
        //外部类名.内部类  变量=外部类对象的引用.new 内部类对象（）
        innerClass.test();
        OuterClass.InnerClass2 innerClass2 = new OuterClass.InnerClass2();
        //外部类名.内部类  变量=new 外部类名.内部类（）
        innerClass2.test();
         /*结果:
         1
         2
         InnerClass的test方法
         OuterClass的test2方法
         1
         InnerClass2的test方法*/
    }
}