Java——类和对象超详细总结

Posted 2021-12-05 地火轰雷

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java——类和对象超详细总结相关的知识，希望对你有一定的参考价值。

文章目录

- 类和对象

类和对象

1.类与对象的初步认识

c语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

Java是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

面向过程注重的是过程，就像我们用手洗衣服，我们需要先用盆接水，然后放入衣服，然后放入洗衣粉，然后用手搓，然后拧干晒起来。

面向对象注重的是对象，就像我们用洗衣机洗衣服，只要把衣服和洗衣服放入洗衣机，然后晒干就可以了，不用去管洗衣机是如何去洗衣服的。

2.类和类的实例化

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

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

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

基本语法

//创建类
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("睡觉！");
    }
}

注意事项

和之前写的方法不同，此处写的方法不带static关键字，我们我们会详细解释static是干什么的。

类的实例化

用类类型创建对象的过程，称为类的实例化

类只是一个模型一样的东西，限定了类有哪些成员。
一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类成员变量。

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

输出结果为：

吃饭！
睡觉！

注意事项

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

3.类的成员

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

此处我们重点介绍前三个。

3.1字段/属性/成员变量

在类中，但是方法外部定义的变量。这样的变量我们称为"字段"或"属性"或"成员变量"(三种称呼都可以，一般不会严格区分)，用于描述一个类中包含哪些数据。

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

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

注意事项

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

默认值规则

对于各种数字类型，默认值为0。

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

对于引用类型(String,Array,以及自定制类)，默认值为null.

Person person = null;
//这个引用不指向任何的对象

Person person = new Person();
Person person2=person;
//person2这个引用指向person这个引用所指向的对象

Person person = new Person();
person = new Person();
person = new Person();
person = new Person();
//一个引用不可以同时指向多个对象 实际指向的是最后一个对象

字段就地初始化

很多时候我们不希望字段使用默认值，而是需要我们显式设定初值，可以这样写：

class Person{
    public String name = "ljj";    
    public int age = 18;
}

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

//执行结果
ljj
18

3.2方法

用于描述一个对象的行为。

class Person{
    public String name = "ljj";    
    public int age = 18;
    
    public void show(){
       System.out.println("我叫"+name+",今年"+age+"岁")； 
    }
}

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

//执行结果
我叫ljj,今年18岁

此处的show方法，表示Person这个对象具有一个"展示自我"的行为。

这样的show方法是和person实例相关联的，如果创建了其他实例，那么show的行为就会发生变化。

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person.show();

//执行结果
我叫李四，今年20岁

3.3 static关键字

修饰属性
修饰方法
代码块
修饰类

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

class TestDemo1{
    public int a;
    public static int count;
}

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

输出结果为：

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

b)修饰方法

如果在任何方法上应用static关键字，此方法称为静态方法。

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

class TestDemo1{
    public int a;
    public static int count;
    
    public static void change(){
        count = 100;
        //a = 10;  error  不可以访问非静态数据成员
    }
}

public class TestDemo {
    public static void main(String[] args) {
        TestDemo1.change();    //  无需创建实例对象就可以调用
        System.out.println(TestDemo1.count);
    }
}

输出结果：

注意事项1：静态方法和实例无关，而是和类相关。因此导致了两个情况：

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

注意事项2：

我们曾经写的方法为了简单，都统一加上了static。但实际上一个方法具体要不要带static，都需要视情形而定。
main方法为static方法。

4.封装

软件开发的本质就是对程序复杂程度的管理，如果一个软件代码复杂程度太高，那么就无法继续维护。如何管理复杂程度？封装就是最基本的方法。

在我们写代码的时候经常会涉及两种角色：类的实现者和类的调用者。

封装的本质就是让类的调用者不必了解类的实现者是如何实现类的，只要知道如何使用就行了。

这样就降低了类使用者的学习和使用成本，从而降低了复杂程度。

4.1 private实现封装

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

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

被private修饰的成员变量或者成员方法，不能被类的调用者使用。

直接使用public

class Person{
    public String name = "ljj";    
    public int age = 18;
    
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("我叫"+person.name+",今年"+person.age+"岁");
    }
}
    
//执行结果
我叫ljj，今年18岁

这样的代码导致类的使用者(main方法的代码)必须要了解Person类内部的实现，才能够使用这个类，学习成本较高。

一旦类的实现者修改了代码(例如把name改成myName)，那么类的使用者就需要大规模的修改自己的代码，维护成本较高。

范例：使用private封装属性，并提供public方法供类的调用者使用。

class Person{
    private String name = "ljj";    
    private int age = 18;
    
    public void show(){
        System.out.println("我叫"+person.name+",今年"+person.age+"岁");
    }
}

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

//执行结果
我叫ljj，今年18岁

此时字段已经使用private来修饰，类的调用者(main方法中)不能直接使用。而需要借助show方法。此时类的使用者就不必了解Person类的实现细节。

同时如果类的实现者修改了字段的名字，类的调用者不需要做出任何修改(类的调用者根本访问不到name,age这样的字段)。

注意事项

private不光能修饰字段，也能修饰方法。
通常情况下我们会把字段设为private属性，但是方法是否需要设为public，就需要视具体情形而定。一般我们希望一个类只提供"必要的"public方法，而不应该把所有的方法都无脑设为public。

4.2 getter和setter方法

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

代码示例

class Person{
    private String name = "ljj";    
    private int age = 18;
    
    public void show(){
        System.out.println("我叫"+person.name+",今年"+person.age+"岁");
    }
}

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

//编译出错
java: age可以在Person中访问private

此时如果需要获取或者修改这个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);
    }
}
    
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("ljj");
       String name = person.getName();
        System.out.println(name);
        person.show();
    }
}

//运行结果
ljj
name:ljj age:0

注意事项

getName即为getter方法，表示获取这个成员的值。

setName即为setter方法，表示设置这个成员的值。

当set方法的形参名字和类中的成员属性名字一样的时候，如果不使用this，相当于赋值，this表示当前实例的引用。

不是所有的字段都一定要提供setter/getter方法，而是要根据实际情况决定提供哪种方法。

在IDEA中可以使用alt+insert(或者alt+F12)快速生成setter/getter方法。在VSCode中可以使用鼠标右键菜单->源代码操作中自动生成setter/getter方法。

5.构造方法

5.1基本语法

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

new执行过程

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

语法规则

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

注意事项

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

代码示例

class Person{
    private String name;    //  实例成员变量    
    private int age;
    private String sex;
    //  默认构造函数  构造对象
    public Person(){
        this.name = "ljj";
        this.age = 10;
        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 TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();    //调用不带参数的构造函数  如果程序没有提供会调用不带参数的构造函数
        p1.show();
        Person person2 = new Person("李四",80,"男”);    //调用不带参数的构造函数  
        p2.show();
    }
}

//执行结果
name:ljj age:10 sex:男
name:李四 age:80 sex:男

5.2 this关键字

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

class Person{
    private String name;    //  实例成员变量    
    private int age;
   //  默认构造函数  构造对象
    public Person(){
        //  this调用构造函数
        this("bit",12,"man");    //  必须放在第一行进行显式
    }
    //  这两个构造函数之间的关系为重载
    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 TestDemo {
    public static void main(String[] args) {
        Person person = new Person();    //  调用不带参数的构造函数
        person.show();
    }
}

//执行结果
name:bit age:12 sex:man

6.认识代码块

字段的初始化方式有：

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

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

6.1什么是代码块

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

根据代码块定义的位置以及关键字，又可分为以下四种：

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

6.2普通代码块

普通代码块：定义在方法中的代码块

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

//执行结果
x1 = 10
x2 = 100

6.3构造代码块

构

以上是关于Java——类和对象超详细总结的主要内容，如果未能解决你的问题，请参考以下文章

面向对象一文了解Java继承（超详细超有趣）

Java基础知识总结（超详细整理）

超详细的Java面试题总结之Java基本知识

Java类和对象-学习笔记（超级详细~~~）