public class Student{
        public String name;
        private int age = 18;
    }

属性可以赋值的位置

class Recursion{
    public static void main(String[] args) {
        Recursion test = new Recursion();
        System.out.println(test.getSum(3));
    }
    public int getSum(int n){
        if(n == 1){
            return 1;
        }else {
            return n * getSum(n-1);
        }
    }
}

• 类的构造方法（构造器） 

作用：1.创建对象  2.初始化对象的信息

特征：1.它具有与类相同的名称  2.它不声明返回值类型。（与声明为void不同） 3.不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

说明： 

1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式：权限修饰符  类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
5.一个类中，至少会有一个构造器。

public class Java1 {
    public static void main(String[] args) {
        //创建类的对象:new + 空参构造器
        Person p = new Person();
        p.setName("张三");
        p.eat();
        p.study();
        //创建类的对象:new + 有参构造器
        Person p1 = new Person("李四");
        p1.eat();
        p1.study();
    }
}

class Person{
    private String name;//名字(private只能在本类中使用)
    private int age;//年龄

    //空参构造
    public  Person(){}
    //有参构造
    public Person(String name) {
        this.name = name;
    }

    //定义属性的get，set方法
    public String getName() {
        return name;
    }

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

    //方法
    public void eat(){
        System.out.println(name + "吃饭");
    }

    public void study(){
        System.out.println(name+ "学习");
    }
}

• 类的成员之——代码块 （或初始化块）

1. 代码块的作用：用来初始化类、对象
2. 代码块如果有修饰的话，只能使用static.
3 分类：静态代码块  vs 非静态代码块
4. 静态代码块
         >内部可以有输出语句
         >随着类的加载而执行,而且只执行一次
         >作用：初始化类的信息
         >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
         >静态代码块的执行要优先于非静态代码块的执行
         >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
5. 非静态代码块
          >内部可以有输出语句
          >随着对象的创建而执行
          >每创建一个对象，就执行一次非静态代码块
          >作用：可以在创建对象时，对对象的属性等进行初始化
          >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
          >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

6. 执行顺序：由父及子 静态先行 

public class BlockTest {
    public static void main(String[] args) {
        Animal a = new Animal();
        System.out.println(a);
    }
}

class Animal{
    String name;
    int age;
    static String desc = "动物"; //静态属性 全类通用

    //构造器
    public Animal(){}

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

    //非静态代码块
    {
        name = "小狗";
        age = 3;
        desc = "我是一只小狗";
        show();
        toString();
    }

    //静态代码块
    static {
        //静态代码块不能调用非静态变量
//        name = "小狗";
//        age = 3;
        desc = "我是一只小狗1";
        show();
//        toString;  //静态代码块不能调用非静态方法
        System.out.println(desc);
    }

    //方法
    public String toString(){
        return "name=" + name + ",age=" +age;
    }

    public static void show(){
        System.out.println("Static方法");
    }
}

//执行结果：
//Static方法
//我是一只小狗1
//Static方法
//name=小狗,age=3

• 类的成员之——内部类 

内部类的定义和使用规范

1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
2. 内部类的分类：成员内部类（静态、非静态）  vs 局部内部类(方法内、代码块内、构造器内)
3. 成员内部类：
          一方面，作为外部类的成员：
              >调用外部类的结构
              >可以被static修饰
              >可以被4种不同的权限修饰
          另一方面，作为一个类：
              > 类内可以定义属性、方法、构造器等
              > 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
              > 可以被abstract修饰

public class InnerClassTest {
    public static void main(String[] args) {
        //创建Dog实例(静态的成员内部类):
        Animal.Dog dog = new Animal.Dog();
        dog.eat();
        dog.show();
        //创建Pig实例(非静态的成员内部类):
        Animal anm = new Animal();
        anm.name = "八戒";
        Animal.Pig pig = anm.new Pig();
        pig.name = "二白";
        pig.eat();
        pig.show("佩奇");
    }
}

class Animal{
    String name;

    public void eat(){
        System.out.println("进食");
    }

    //静态成员内部类
    static class Dog{
        public void eat(){
            System.out.println("小狗吃饭");
        }
        public void show(){
            System.out.println("小狗");
//            Animal.this.eat(); //静态类中不能引用非静态方法
            eat();
        }
    }

        //非静态成员内部类
        class Pig{
        String name;

        public void eat(){
            System.out.println("小猪吃饭");
        }

        public void show(String name){
            System.out.println("小猪");
            Pig.class.getClass();
            Animal.this.eat();
            System.out.println(name);//方法的形参
            System.out.println(this.name);//内部类的形参
            System.out.println(Animal.this.name);//外部类的形参
        }
    }
}

//执行结果
/*
小狗吃饭
小狗
小狗吃饭
小猪吃饭
小猪
进食
佩奇
二白
八戒
*/

4. 局部内部类：                                                                                                                                          4.1 只能在声明它的方法或构造器或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类
         4.2 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型
         4.3 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
         4.4 局部内部类可以使用外部类的成员，包括私有的。
         4.5 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
         4.6 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
         4.7 局部内部类不能使用static修饰，因此也不能包含静态成员

public class InnerClassTest1 {
    public static void main(String[] args) {
        Person1 p = new Person1();
        p.name = "老李";
        p.eat();
    }
}

class Person1{
    String name;

    {
        //定义在代码块中的局部内部类
        class CC{
            public void disPlay(){
                System.out.println("定义在代码块中的局部内部类");
                System.out.println(name);
            }
        }
    }

    public Person1(){
        //定义在构造器的局部内部类
        class AA {
            public void disPlay1() {
                System.out.println("定义在构造器中的局部内部类");
                System.out.println(name);
            }
        }
    }

    public void eat(){
        int num = 10;
        System.out.println("吃饭");
        //局部内部类（方法中）
//       public class BB {  //不能使用 public,protected,缺省,private 来修饰
        class BB {
            public void disPlay(String name) {
                System.out.println("定义在方法中的局部内部类");
                System.out.println(name);//方法的形参
                System.out.println(Person1.this.name);//外部类的name属性
                System.out.println(num + 1);//调用外部方法的局部变量
            }
        }
        //先声明，后使用
        BB bb = new BB();
        bb.disPlay("老王");
    }
}

//执行结果
/*
吃饭
定义在方法中的局部内部类
老王
老李
11
*/

5. 重点关注如下的3个问题
         5.1 如何实例化成员内部类的对象
         5.2 如何在成员内部类中区分调用外部类的结构
         5.3 开发中局部内部类的使用   

• 拓展 ——UML类图

说明：本篇文章部分内容和图片引用尚硅谷官网内容，特此说明。@尚硅谷官网地址