九、类和对象

Java 语言学习的网址：菜鸟教程.

1. Java语言的特性

答：简单性、面向对象、分布式、健壮性、安全性、体系结构中立、可移植性、解释性、高性能、多线程、动态性。

2. 类和对象

学习地址.
类：类是一个模板，它描述一类对象的属性和行为。
对象：对象是一个个体，有状态和行为。
即：类就是一类对象的统称，对象就是这一类具体化的一个实例。
例如：

• 一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 男人、女人是类；张三李四是对象；
• 汽车是类；某个奔驰汽车是对象；
• 狗是类；小明养的藏獒是对象。

在Java中，使用关键字 class 来声明一个类。
代码示例：

/*
这两个都是类
*/
class Person {
    public String name;
    public int age;
    public String sex;
}
public class TestDemo {
    
}

类中的元素称为：成员属性。
类中的函数称为：成员方法。
一个类可以包含以下类型变量：

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中的方法、构造方法和特定类的语句块访问。
• 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

3. 创建对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。
代码示例：

class Person {
    //类的组成：
    /**
     * 1.属性(成员变量)
     * 成员变量：(1).普通成员变量
     *          (2).静态成员变量
     */
    //(1)普通成员变量
    public String name;
    public int age;
    public String sex;
    public int count2 = 0;
    //(2)静态成员变量   不依赖于对象，只需要通过类名就可以访问
    public static int count = 0;
    /**
     * 2.行为(成员方法)
     * 成员方法：(1).普通成员方法
     *          (2).静态成员方法
     */
    //(1)普通成员方法
    public void eat() {//吃饭这个行为
        int a = 10;//局部变量(需要初始化)
        System.out.println(name+"快来吃饭！！");
    }
    //(2)静态成员方法
    public static void staticFunc() {
        System.out.println("staticFunc()函数被调用了");
    }
    public void show() {
        System.out.println("姓名："+name+";"+" "+"年龄："+age+";"+"性别："+sex);
    }
}

类的实例化：

class Person {
    public String name;//普通成员变量
    public int age;
    public String sex;
    //普通成员方法
    public void eat() {//吃饭这个行为
        System.out.println(name+"快来吃饭！！");
    }
    public void show() {
        System.out.println("姓名："+name+";"+" "+"年龄："+age+";"+"性别："+sex);
    }
public class TestDemo {
/**
     *实例化
     * 类名  变量 =  new 类名()
     * 调用普通方法和普通成员变量
     * 通过：(引用.普通成员变量
     *       引用.普通成员方法 )    调用
     */
    public static void main2(String[] args) {
        Person per1 = new Person();//实例化成功
        per1.name = "caocao";
        per1.age = 18;
        per1.sex = "男";
        per1.show();
        System.out.println(per1);//输出：Person@1b6d3586
        System.out.println("==================");
        //可以通过一个类实例化多个对象
        Person per2 = new Person();
        per2.name = "zhangsan";
        per2.age = 28;
        per2.sex = "男";
        per2.show();
    }
}    

实例化一个对象的步骤：

• 1.为对象分配内存
• 2.调用合适的构造方法。这就意味着构造方法不止一个。
  当一个类提供了其他的构造方法，那么编译器就会帮我们自动生成一个不带有参数的构造方法。
  只有构造方法完成了以后，才有了一个真正的对象。
  
  当类的实例化完成以后，局部变量会在栈上开辟内存，而其余的成员属性都会在堆上。

4. 类的成员

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

4.1 字段/属性/成员变量

在类中, 但是方法外部定义的变量. 这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”。其作用就是用于描述一个类中包含哪些数据。

4.2 方法

方法就是一段语句的集合，用来执行一个功能，描述对象的行为。

4.3 static 关键字

a.修饰属性
Java静态属性和类相关, 和具体的实例无关. 即, 同一个类的不同实例共用同一个静态属性。
静态的不依赖于对象，所以调用静态成员的时候，不管是什么对象，都可以调用它。调用方法：类名 . 属性。
b.修饰方法
如果在任何方法上应用 static 关键字，此方法称为静态方法。

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

注意： 静态方法和实例无关, 而是和类相关. 因此这导致了两个情况：

• 静态方法的内部不能调用非静态的成员方法(非静态数据成员和方法都是和实例相关的).
• this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也是和当前实例相关).

代码内存布局图解示例：

5. 封装

OOP思想： Object Oriented Programming 面向对象程序设计。
OOP 语言的特征：继承、封装、多态。

软件开发的本质就是对程序复杂度的管理，如果一个代码的程序复杂度太高，那么就很难维护。封装就是最基本的管理程序复杂度的方法。
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度.

5.1 private实现封装

被 private 修饰的成员变量或者成员方法, 不能在类外被访问。
封装：使用关键字 private 来修饰成员变量或者成员方法，然后统一提供对应的 get 和 set 方法。好处是：类的调用者对类的学习成本降低了。
代码示例:

class Student {
    //public 公开的，公有的。
    private String name;
    private int age;
    private String sex;
    //利用快捷键：Alt+f12，然后选择Getter and Setter,进去之后按住shift键，选中要选的函数，后面的关于set和get的函数全部会被调用出来。取代了上面需要一一写出的代码
    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}
public class TestDemo2 {
    public static void main1(String[] args) {
        Student stu = new Student();
        stu.setName("caocao");
        System.out.println(stu.getName());
        stu.setAge(10);
        System.out.println(stu.getAge());
    }
}

上面的代码就是一个简单的封装。通过代码我们可以看到，在 Student 这个类中，我们用关键字 private 封装了一些成员变量，那么我们在后面的调用中之所以能够调用出它的具体的实例化对象，就是因为调用了对应的 get 和 set 方法，所以才能实现。但是对于原来类里面的成员属性，我们并没有改变它，确保了别人在调用它的时候，也能正常调用。
注意事项：

• get 方法表示获取这个成员的值。
• set 方法表示设置这个成员的值。
• 不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法.
• this 代表了当前对象的引用。

注：在 IDEA 中，调用 get 和 set 方法的快捷键是 ：Alt+f12，然后选择Getter and Setter,进去之后按住shift键，选中要选的函数。

关于 this 的使用：

操作	意义
this.data	访问成员变量
this.func()	调用成员方法
this（）	调用构造方法

静态方法内部不能使用 this ，因为静态方法不依赖于对象。

6. 构造方法

6.1 基本语法

普通方法的语法结构：

返回值  方法名  （形参） {
     方法体
}

构造方法：就是一个没有返回值的方法，且方法名和类名是一样的。
构造方法的作用就是实例化对象，而且每一个类里面都会有一个默认的不带参数的构造方法。
注意事项：

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

代码示例：

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

    public Student() {
        this("caocao");//表示调用带有一个参数的构造方法。且this必须放在第一行,只能有一个
        System.out.println("不带参数的构造方法执行了！");
    }
    public Student(String name) {
        this.name = name;
        System.out.println("带有1个参数的构造方法执行了！！");
    }
    //利用快捷键：Alt+f12，然后选择Constructor ,按住shift键，选中所需的方法
    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("调用了带有3个参数的构造方法！！");
    }
}
public class TestDemo2 {
    public static void main2(String[] args) {
        Student student = new Student("caocao");//输出：带有1个参数的构造方法执行了！！
        System.out.println("=================");
        Student student2 = new Student();//输出：不带参数的构造方法执行了！
    }
}

7. 代码块

字段初始化的方式有：

• 就地初始化
• 使用构造方法初始化
• 使用代码块初始化

前两种方式前面已经学习过了, 接下来我们介绍第三种方式, 使用代码块初始化。

7.1 什么是代码块

使用 { } 定义的一段代码.
根据代码块定义的位置以及关键字，又可分为以下四种：

• 普通代码块
• 构造块
• 静态块
• 同步代码块

7.2 普通代码块

即定义在方法中的代码块。

public class Main{ 
    public static void main(String[] args) { 
     { //直接使用{}定义，普通方法块
         int x = 10 ; 
         System.out.println("x1 = " +x); //输出：x1 = 10
     } 
     int x = 100 ; 
     System.out.println("x2 = " +x); //输出：x2=100
    } 
} 

7.3 构造代码块

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

{
        //一般初始化实例数据成员
        this.name = "sdjdjfi";
        count = 10;
        this.age = 10;
        System.out.println("实例代码块！可执行多次");
    }

注意：实例代码块优先于构造函数执行。

7.4 静态代码块

使用static定义的代码块。一般用于初始化静态成员属性。
静态代码块只能执行一次，且是最先执行的。

static {
        //初始化静态的数据成员
        count = 9990;
        System.out.println("静态代码块！只能执行一次");
    }

总结：几种代码块的执行顺序

• 1.静态代码块。与顺序有关
• 2.示例代码块。与顺序有关
• 3.构造方法

8. 补充

8.1 toString 方法

当我们想把对象的属性打印出来的时候，我们必须自己构造一个 show 函数，然后调用它，这是一种方法。其实在 Object 类里面提供了一个 toString 方法，可以将对象自动转成字符串.

代码示例：

class Student {
    //public 公开的，公有的。
    private String name;
    private int age;
    public String sex;
    
    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show() {
        System.out.println("姓名："+name+";"+" "+"年龄："+age+";"+"性别："+sex);
    }
    
    //toString 方法：该方法的快捷键：Alt+insert(f12)
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student stu = new Student("张三",18,"男");
        stu.show();//输出：  姓名：张三； 年龄：18； 性别：男
        System.out.println(stu);//输出：  Student{name='caocao', age=19,sex='男'}
    }

注意事项:

• toString 方法会在 println 的时候被自动调用.
• 将对象转成字符串这样的操作我们称为 序列化.
• toString 是 Object 类提供的方法, 我们自己创建的 Student 类默认继承自 Object 类, 可以重写 toString 方法实现我们自己版本的转换字符串方法.
• @Override 在 Java 中称为 “注解”, 此处的 @Override 表示下面实现的 toString 方法是重写了父类的方法.
• IDEA快速生成Object的toString方法快捷键：alt+f12(insert)

8.2 匿名对象

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

• 没有引用的对象称为匿名对象.
• 匿名对象只能在创建对象时使用.
• 如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象.

代码示例：

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();//通过匿名对象调用方法
    } 
} 
// 执行结果
name：caocao age：19 

总结

• 一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
• 类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
• 静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
• this关键字代表的是当前对象的引用。并不是当前对象。