Java基础-类和对象

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。类与对象的概念你可以理解为：类就是一类对象的统称。对象就是这一类具体化的一个实例。即类为模板，而对象为一个一个的实例化。

一、类和类的实例化

class Person {
  public int age;//成员属性 实例变量
  public String name;
  public String sex;
  public void eat() {//成员方法
   System.out.println("吃饭!"); 
 }
  public void sleep() {
   System.out.println("睡觉!"); 
 }
}
public static void main(String[] args) {
        //通过new来实例化对象
        Person person=new Person();
        person.eat();成员方法调用需要通过对象的引用调用
}

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

二、类的成员

2.1 属性

在类中但是方法外部定义的变量. 这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”

class Person{
    public String name;  //实例成员变量
    public int age;
    public static int COUNT;   //静态成员变量，属于类本身，只有一份，存在方法区
    public final int SIZE=10;  //被final修饰的常量属于对象，后续不能被修改
    public final static int SIZE1=100;  //静态常量，属于类本身，只有一份且后续不能被修改


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

    }

输出：

null
0

注：
对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值

1. 对于各种数字类型, 默认值为 0.
2. 对于 boolean 类型, 默认值为 false.
3. 对于引用类型(String, Array, 以及自定制类), 默认值为 null

2.2 方法

class Person{
    public String name;  //实例成员变量
    public int age;
    public static int COUNT;   //静态成员变量，属于类本身，只有一份，存在方法区
    public final int SIZE=10;  //被final修饰的常量属于对象，后续不能被修改
    public final static int SIZE1=100;  //静态常量，属于类本身，只有一份且后续不能被修改

    //实例成员方法
    public void eat(){
        System.out.println("人吃饭！");
    }

    public void sleep(){
        System.out.println("人睡觉！");
    }

    //静态方法
    public static void change(){
        COUNT=100;
    }

}
public class TestDemo {
    public static void main(String[] args) {
                Person person=new Person();
                person.eat();
                person.sleep();

    }

输出：

人吃饭!
人睡觉!

2.3 static 关键字

class Person{
    public String name;  //实例成员变量
    public int age;
    public static int COUNT;   //静态成员变量，属于类本身，只有一份，存在方法区
    public final int SIZE=10;  //被final修饰的常量属于对象，后续不能被修改
    public final static int SIZE1=100;  //静态常量，属于类本身，只有一份且后续不能被修改
 }
 
public static void main(String[] args) {
        Person person=new Person();
        person.age++;
        Person.COUNT++;
        System.out.println(person.age);
        System.out.println(Person.COUNT);
        System.out.println("=============");
        Person person1=new Person();
        person1.age++;
        Person.COUNT++;
        System.out.println(person.age);
        System.out.println(Person.COUNT);

    }

输出：

1
1
=============
1
2

count被static修饰，是所有类共享且不属于对象的，访问方式为：类名 . 属性
无论是静态类还是静态方法都是属于类的，而不属于类的对象，因此可以直接同过类名.的方式来访问而不需要创建类的实例，故静态方法不能直接使用非静态数据成员或调用非静态方法，因为非静态数据成员和方法都是和实例相关的。

三、封装

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了。这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度。
封装的实现：使用 private 封装属性, 并提供 public 方法供类的调用者使用.

class Student{
    private String name;
    private int age;

    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 static void main(String[] args) {
        Student student=new Student();
        student.setAge(10);
        System.out.println(student.getAge());
        student.setName("zhangsan");
        System.out.println(student.getName());

    }
}

此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助getter / setter 方法. 此时类的使用者就不必了解 Student 类的实现细节.
getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置这个成员的值.

四、构造方法

class Student{
    private String name;
    private int age;

    //默认构造函数
    public Student() {
        //可以使用this调用构造函数
        this("fc",23);//必须将此行代码放到第一行
        System.out.println("我是构造函数");
    }

    //带有两个参数的构造函数
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
public static void main(String[] args) {
        Student student=new Student("张三",10);
        System.out.println(student.getName());
        System.out.println(student.getAge());
        
    }
}

输出：

张三
10

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.
因此，new的过程分为两步:

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

构造方法的语法规则：

1. 方法名称必须与类名称相同
2. 构造方法没有返回值类型声明
3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参的构造函数），如果存在多个构造函数，则根据参数的个数以及类型自动选择构造函数，故构造方法支持重载， 规则和普通方法的重载一致。

五、代码块

代码块就是使用 {} 定义的一段代码
根据代码块定义的位置以及关键字，又可分为实例代码块、静态代码块

class Student{
    private String name;
    private int age;

    //默认构造函数
    public Student() {
        //可以使用this调用构造函数
        this("fc",23);//必须将此行代码放到第一行
        System.out.println("我是构造函数");
    }

    //带有两个参数的构造函数
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //实例代码块
    {
        System.out.println("我是实例代码块");
    }

    //静态代码块
    static{
        System.out.println("我是静态代码块");
    }
public class TestDemo {
    public static void main(String[] args) {
        Student student=new Student();
    }
}

输出：

我是静态代码块
我是实例代码块
我是构造函数

注：
1.静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
2.静态代码块执行完毕后, 实例代码块执行，再然后是构造函数执行。
3.如果都是静态代码块则和据静态代码块出现的顺序有关。

六、总结

1. 类是模板，对象是具体实例。
2. 静态的属性或者静态的方法不依赖于对象，直接通过类名.的方式就可调用。
3. 代码块执行的顺序：静态代码块->实例代码块->构造函数。
4. this关键字代表的是当前对象的引用而不是当前对象。
5. 如果一个对象只被使用一次的话，可以考虑使用匿名对象

本文地址：https://blog.csdn.net/qq_42681119/article/details/111832339