1.类的定义格式：

class + 类名（建议使用大驼峰格式）
class ClassName {
    //字段/成员变量
    String name;
    int  age;
    //方法 
    //访问权限 + 返回值 + 方法名 (参数列表)
    public void print () {
        System.out.println ("姓名" + this.name + "年龄" + this.age);
    }
}

2.类的实例化

通过类类型创建对象的过程，称为类的实例化

class Student {
    public String name;
    public int age;

    public void print () {
        System.out.println("姓名：" + this.name + " 年龄:" + this.age);
    }

}

public class Main {
    public static void main(String[] args) {
        Student st = new Student();
        st.name = "hh";
        st.age = 18;
        st.print();
    }
}

 new 关键字用于创建一个对象的实例

使用 . 操作符来访问对象中的属性和方法

3.构造方法与初始化

初始化：就地初始化，默认初始化

默认初始化，对象成员被申请时，对象包含的成员已经设置好了初始值

就地初始化

class Student {
    //就地初始化
    public String name = "张三";
    public int age = 18;


    public void print () {
        System.out.println("姓名 " + this.name + " 年龄" + this.age);
    }
}

java构造方法

构造方法是一种特殊的成员方法，名字与类名相同，在创建对象时编译器自动调用，并且在该对象的生命周期只执行一次

构造方法没有返回值，void的不能设置

分为：默认构造，无参构造，有参构造。

默认构造：如果用户未定义构造方法，编译器会自动为类生成一份默认构造方法，生成的默认构造方法是无参的

无参构造，有参构造：

class Student {
    public String name;
    public int age;

    Student () {
        System.out.println("无参构造");
    }

    Student (String name , int age) {
        System.out.println("有参构造");
    }
    
}

public class Main {
    public static void main(String[] args) {
        Student st1 = new Student();
        Student st2 = new Student("张三",18);
    }
}

4.this引用

this引用代表当前对象的引用

this引用是成员方法中第一个隐藏参数，编译器会自动接收

class Student {
    public String name;
    public int age;
    
    public void print (Student this) {
        System.out.println("姓名：" + this.name + " 年龄:" + this.age);
    }
}

public class Main {
    public static void main(String[] args) {
        Student st = new Student();
        st.print();
    }
}

this引用可以调用构造函数

class Student {
    public String name;
    public int age;

    Student () {
        this("张三",18);
    }

    Student (String name , int age) {
        this.name = name;
        this.age = age;
    }

    public void print () {
        System.out.println("姓名 " + this.name + " 年龄" + this.age);
    }
}

public class Main {
    public static void main(String[] args) {
        Student st = new Student();
        st.print();
    }
}

注意：调用时必须放在第一行，且不能成环 

  如 ：

this引用可以用于区别相同名称

5.访问限定符

访问权限可以控制方法或者字段能否直接在类外使用，Java提供了4中访问限定符

6.static成员

特点：

在java中static修饰的成员称为静态成员，也叫类成员，是所有对象所共享的，是类的属性。

不存储在某个对象的空间中，既可以通过对象名来访问，也可以通过类名来访问，推荐使用类名进行访问。

类变量存储在方法区当中。

静态方法没有隐藏的this引用参数，在静态方法中不能访问任何非静态的成员变量。

class Student {
    static int classRoom = 3;
    private String name;
    private int age;

    public static void getName () {
        System.out.println(name);
        System.out.println(this.name);
    }//编译失败，静态方法不能访问非静态成员，不能使用this关键字

    public static void getclassRoom () {
        System.out.println(classRoom);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        
        System.out.println(Student.classRoom);//通过类名访问静态成员变量
        System.out.println(s.classRoom);//通过对象访问静态成员变量

        Student.getclassRoom();//通过类名调用静态方法
        s.getclassRoom();//通过对象调用静态方法

    }
}

static成员变量初始化有两种方式：

1.就地初始化：在定义时直接给出初始值

class Student {

    public static String Room = "R12";
    
    //....

}

2.静态代码块初始化

        请看下文！

7.代码块

使用{}定义的一段代码称之为代码块，分为以下四种：

普通代码块

构造代码块

静态代码块

同步代码块（多线程部分，暂且不提）

1）普通代码块：定义在方法中的代码块

class Student {
    public void method () {
        {
            System.out.println("普通代码块");
        }
        int x = 10;
        System.out.println(x);
    }
}

2）构造代码块：定义在类中的代码块(不加修饰符)，也叫实例代码块，一般用于初始化实例成员变量

class Student {
    private String name;
    private int age;
    private String sex;

    public Student () {
        System.out.println("构造函数");
    }

    {
        name = "张三";
        age = 18;
        sex = "男";
        System.out.println("代码块1的调用");
    }

    {
        name = "李四";
        age = 28;
        sex = "男";
        System.out.println("代码块2的调用");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s);
    }
}

实例代码块的执行优于构造方法的执行，因为编译完成后编译器会将实例代码块的代码拷贝到构造方法第一条语句前。

3）静态代码块

使用static修饰的代码块称为静态代码块，一般用于初始化静态成员变量

class Student {
    private String name;
    private int age;
    private String sex;
    private static String classRoom;

    public Student () {
        System.out.println("构造函数");
    }

    {
        name = "张三";
        age = 18;
        sex = "男";
        System.out.println("代码块1的执行");
    }

    static {
        classRoom = "3班";
        System.out.println("静态代码块");
    }

    {
        name = "李四";
        age = 28;
        sex = "男";
        System.out.println("代码块2的执行");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println("=============");
        Student s2 = new Student();
    }
}

 静态代码块的执行优于实例代码块的执行，且不论生成多少对象，只会执行一次

8.成员内部类

在外部类中，定义类的位置与外部类成员位置相同，称为成员内部类

1）普通内部类

public class Main {
    private int a;
    private int b;

    public Main () {
        a = 1;
    }

    public void method1 () {
        System.out.println("外部类");
    }

    class innerClass {
        int a;
        int c;

        public innerClass () {
            a = 5;
        }

        public void method2 () {

            //可以直接访问外部类成员
            method1();
            System.out.println(b);

            System.out.println(a);//相同名称时优先访问内部类自己的

            System.out.println(Main.this.a);//访问同名的外部类成员需要用外部类名称.this.成员
            
            System.out.println("内部类");
        }

    }

    public static void main(String[] args) {
        //要访问内部类成员，必须创建内部类对象
        //要创建内部类对象，必须借助外部类
        //创建内部类的两种方式
        //1.
        Main.innerClass inner1 = new Main().new innerClass();

        //2.先将外部类对象创建出来，在创建内部类对象
        Main m = new Main ();
        Main.innerClass inner2 = m.new innerClass();
        inner2.method2();
    }
}

注意：

1.外部类中的任何成员可以，在内部类方法中访问

 2.内部类方法访问相同名称的成员优先访问自己的，访问外部类的同名成员，需要外部类名.this. 成员名

3.内部类也受public，private等访问限定符修饰

4.访问内部类成员，需要创建内部类的对象

2）静态内部类

被static修饰的内部类称为静态内部类

public class Main {
    private int a;
    private static int b = 10;

    public void method1 () {
        System.out.println("外部类");
    }

    public static void methodStatic () {
        System.out.println("静态外部类成员方法");
    }

    static class innerClass {

        public void method2 () {

            //静态内部类只能访问外部类静态成员
            //method1();//编译失败
            //System.out.println(a);//编译失败

            methodStatic();
            System.out.println(b);
        }

    }

    public static void main(String[] args) {
        //静态内部类的创建，直接通过类名创建即可
        Main.innerClass inner = new Main.innerClass();
    }
}

3）局部内部类

定义在外部类的方法体或{}中，该内部类只能在其定义的位置使用

public class Main {
    int a = 10;


    public void method1 () {
        int b = 10;
        System.out.println("外部类");
        class innerClass {

            public void method2 () {
                System.out.println("局部内部类");
                System.out.println("a = " + a + "b = " + b);
            }
        }
        //只能在定义处使用
        innerClass inner = new innerClass();
        inner.method2();
    }

    public static void main(String[] args) {
        //Main.innerClass inner1 = null;//编译失败
    }
}