// 创建类

class < class_name >{

field; //成员属性

method; //成员方法

}

// 实例化对象

< class_name > <对象名> = new < class_name >；

class 为定义类的关键字， ClassName 为类的名字， { } 中为类的主体。类中的元素称为：成员属性。类中的函数称为：成员方法。

举例：

class Person {
    public int age;//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {     //成员方法
       System.out.println("吃饭!");  
   }
    public void sleep() {
       System.out.println("睡觉!");  
   }
}

public class Main{

 public static void main(String[] args) {
        Person person = new Person();   //通过new实例化对象
        person.eat();      //成员方法调用需要通过对象的引用调用
        person.sleep();
        //产生对象     实例化对象
        Person person2 = new Person();
        Person person3 = new Person();
 }
}

注意：

new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建对个实例

二、类的成员

1、字段/属性/成员变量

class Person {
    public String name;   // 字段
    public int age;
 }

class Test {
    public static void main(String[] args) {
      Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);
   }
}

使用 . 访问对象的字段.
"访问" 既包含读, 也包含写.
对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值

默认值规则：

对于各种数字类型，默认值是0.

对于boolean 类型，默认值为 false.

对于引用类型，默认值为 null

2、认识 null

null 在 Java 中为 " 空引用 ", 表示不引用任何对象如果对 null 进行 . 操作就会引发异常

3、static关键字

1、修饰属性

class TestDemo{
    public int a;
    public static int count; 
}
public class Main{
    
 public static void main(String[] args) {
        TestDemo t1 = new TestDemo();
        t1.a++;
        TestDemo.count++;
        System.out.println(t1.a);
        System.out.println(TestDemo.count);
        System.out.println("============");
        TestDemo t2 = new TestDemo();
        t2.a++;
        TestDemo.count++;
        System.out.println(t2.a);
        System.out.println(TestDemo.count);
   }
}

输出结果为：
1 1 ============ 1 2

count被static所修饰，所有类共享。且不属于对象，访问方式为：类名 . 属性

2、修饰方法

（1）如果在任何方法上应用 static 关键字，此方法称为静态方法。（2）静态方法属于类，而不属于类的对象。（3）可以直接调用静态方法，而无需创建类的实例。（4）静态方法可以访问静态数据成员，并可以更改静态数据成员的值（5）若方法被 static 修饰，则在方法内部不能访问非静态数据成员

三、封装

1、定义

语法层次上，字段和方法都被private修饰，此时就说这个字段或方法进行了封装

2、访问权限修饰限定符

private/ public 这两个关键字表示 " 访问权限控制 " .

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用
private 不光能修饰字段, 也能修饰方法

3、getter 和 setter 方法

如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法

class Person { 
     private String name;//实例成员变量
     private int age; 
 
     public void setName(String name){ 
         //name = name;//不能这样写
         this.name = name;//this引用，表示调用该方法的对象
     } 
     public String getName(){ 
         return name; 
     } 
 
     public void show(){ 
         System.out.println("name: "+name+" age: "+age); 
     } 
}

getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置这个成员的值.
在 IDEA 中可以使用 alt + insert ( 或者 alt + F12) 快速生成 setter / getter 方法 . 在 VSCode 中可以使用鼠标右键菜单 -> 源代码操作中自动生成 setter / getter 方法 .

4、封装的意义

（1）安全

（2）降低了类的使用成本

四、构造方法

构造方法是一种特殊方法 , 使用关键字 new 实例化新对象时会被自动调用 , 用于完成初始化操作

1、语法规则

1. 方法名称必须与类名称相同 2. 构造方法没有返回值类型声明 3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

2、注意事项

（1）如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数（2）若类中定义了构造方法，则默认的无参构造将不再生成 . （3）构造方法支持重载 .

3、this 关键字

this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法

五、认识代码块

使用 { } 定义的一段代码.

1、普通代码块

定义在方法中的代码块

2、构造块

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

实例代码块优先于构造函数执行

3、静态块

使用static定义的代码块。一般用于初始化静态成员属性

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

六、匿名对象

匿名只是表示没有名字的对象

1、没有引用的对象称为匿名对象

2、匿名对象只能在创建对象时使用

3、如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象

代码示例：

class Person { 
   private String name; 
   private int age; 
   public Person(String name,int age) { 
     this.age = age; 
     this.name = name; 
   } 
   public void show() { 
     System.out.println("name:"+name+" " + "age:"+age); 
   } 
} 
public class Main { 
    public static void main(String[] args) { 
        new Person("caocao",19).show();//通过匿名对象调用方法
   } 
}

码农公寓

一、类的初步认识

1、基本认识

2、实例化