JAVA类与对象

面向对象就是用代码来描述客观世界的事物的一种方式，一个类主要包括一个事物的属性和行为。

类就是一类对象的统称。对象就是这一类具体化的一个实例。

简单的例子：

我们制作冰棒的模子就是一个类，而通过这个模子可以做出冰棒。那么在这个例子当中，类就是那个模子，而冰棒就是那个对象，所以冰棒就是一个实体。一个模子可以实例化无数个对象。

总结：类相当与一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。

声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，Java使用关键字class来声明类。

注：一个java文件中可以有任意多个类,接口或是注解…但是只能有一个类是public的,而且这个类的名字要和文件同名,比如public类名为A则文件名就应当为A.java

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

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 Test {
    public static void main(String[] args) {
        Person person = new Person();//通过new实例化对象
        person.eat();//成员方法调用需要通过对象的引用调用
        person.sleep();
        //产生对象  示例化对象
        Person person1=new Person();
        Person person2=new Person();
    }
}

类的成员包含：字段，方法，代码块，内部类和接口等。

字段/属性/成员变量：在类中，把方法外部定义的变量称为字段，属性，或者是成员变量。（这三者一般不区分）

class Person {
    public String name="boge";
    public int age=18;//成员变量
}
class Test {
    public static void main(String[] args) {
        Person person = new Person();//产生一个新的对象
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

注意事项：

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

：null 在Java中为“空引用”，表示不引用任何对象。类似于C语言的空指针。如果对null进行“."操作就会引发异常。
eg:

：如果我们不希望使用默认值，而是需要显示设定初值。可以这样写：

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

：参考文章https://blog.csdn.net/qq_52988578/article/details/119812422

• 一：修饰属性
• 二：修饰方法
• 三：代码块
• 四：修饰类

修饰属性：Java静态属性和类相关，和具体的实例无关。换句话说，同一个类的不同实例共用同一个静态属性。

class Person {
    public int a;
    public static int count;
    //a与count初始值都为0
}
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.a++;
        person.count++;
        System.out.println(person.a);//1
        System.out.println(person.count);//1
        Person person1 = new Person();
        person1.a++;
        person.count++;
        System.out.println(person1.a);//1
        System.out.println(person1.count);//2
    }
}

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

修饰方法：
如果在方法上应用static关键字，此方法称为静态方法。

• 静态方法属于类，而不属于类的对象
• 可以直接调用静态方法，而无需创建类的实例
• 静态方法可以访问静态数据成员，并可更改静态数据成员的值。

class  TestDemo {
     public static int count;
     public static void change() {
         count = 100;
     }
     public static void testchnage() {
         count = 101;
     }
}
public class Test {
    public static void main(String[] args) {
        TestDemo.change();
        System.out.println(TestDemo.count);
        TestDemo.testchnage();
        System.out.println(TestDemo.count);
    }
}

封装（Encapsulation）：是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

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

• 被public修饰的成员变量或者成员方法，可以直接被类的调用者使用
• 被private修饰的成员变量或者成员方法，不能被类的调用者使用。

我们知道，当我们使用private来修饰字段的时候，我们无法直接使用这个字段了。

代码示例：

此时我们如果需要获取或者修改这个private属性，就需要使用 getter和setter方法。

class TestDemo {
    private String name = "小明";
    public void setName(String name) {
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void show() {
        System.out.println("我是"+name);
    }
}
public class Test {
    public static void main(String[] args) {
        TestDemo t = new TestDemo();
        t.setName("xiaoming");
        String name = t.getName();
        System.out.println(name);
        t.show();
    }
}

注意事项：

• getName即为getter方法，表示获取这个成员的值
• setName即为setter方法，表示设置这个成员的值。

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

• 为对象分配内存空间
• 调用对象的构造方法

语法规则

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

注意事项

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

class Person {

    private String name;//实例成员变量
    private int age;
    private String sex;
    //默认构造函数 构造对象
    public Person() {
        this.name = "caocao";
        this.age = 12;
        this.sex = "男";
    }
    //带有3个参数的构造函数
    public Person(String name,int age,String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
         }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }

}
public class Test{
    public static void main(String[] args) {
        Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
        p1.show();
        Person p2 = new Person("zhangna",18,"女");//调用带有3个参数的构造函数
        p2.show();
    }
}