Java——类和对象

目录

  • 前言
  • 1.面向对象与面向过程
    • 两者有什么区别呢?
  • 2.类
    • 2.1类的概念
    • 2.2类的定义
  • 3.类的实例化
  • 4.this引用
    • 4.1 为什么需要this引用
    • 4.2 this的应用
  • 5.对象的构造和初始化
    • 5.1 初始化对象
    • 5.2 定义构造方法
      • 5.2.1 概念
      • 5.2.2 特点
      • 5.2.3 示例
  • 6. 封装
    • 6.1 封装的概念
    • 6.2 访问限定符
    • 6.3 包
      • 6.3.1 包的概念
      • 6.3.2 包的特点
      • 6.3.3 包的命名规则
      • 6.3.4 导入包中的类
  • 7. stratic成员
    • 7.1 静态变量(类变量)
    • 7.2静态方法
    • 7.3 静态代码块
  • 8. 代码块
    • 8.1 代码块分类
      • 8.1.1 普通代码块
      • 8.1.2 构造代码块
      • 8.1.3 静态代码块
  • 9. 内部类
    • 9.1 成员内部类
    • 9.2 静态内部类
    • 9.3 匿名内部类
  • 总结

前言

C语言是一个面向过程的语言,而Java是一个面向对象的语言,强调类和对象的概念,以面向对象的方式来编写代码,本篇文章就带大家了解java中类和对象有关的内容。

1.面向对象与面向过程

上面也说了,C语言是一个面向过程的语言,它的设计思想更加接近硬件和底层操作。在C语言中,程序主要由函数组成,程序的执行是按照函数调用的顺序来进行的。C语言提供了丰富的控制结构和指针操作,使得程序员可以更加灵活地管理内存和处理底层细节。
Java是一种面向对象的编程语言,它强调对象和类的概念,允许开发人员以面向对象的方式编写代码。面向对象编程 (OOP) 是一种编程范式,其中数据和行为被组织为对象,对象之间通过消息传递进行交互。Java通过类、对象、封装、继承和多态等概念来实现面向对象编程。
总的来说,Java是一种高级面向对象的编程语言,适合开发大型应用程序和跨平台应用,而C语言则更偏向于系统编程和嵌入式开发,因为其更接近底层硬件操作。两者在设计哲学和用途上有所不同,开发者可以根据项目需求和个人偏好选择适合的编程语言。

两者有什么区别呢?

比如我们来描述一个汽车的概念。
在面向对象编程中,我们将汽车视为一个对象,具有属性和行为。我们可以创建一个“Car”类来表示汽车,该类具有属性(如颜色、品牌、型号)和行为(如加速、刹车、转弯)。然后,我们可以实例化这个类创建具体的汽车对象,比如一辆红色的奔驰轿车。每辆汽车都是一个独立的实体,拥有自己的状态和行为。

public class Car {
    String color;
    String brand;
    String model;
    
    public void accelerate() {
        // 加速的行为
    }
    
    public void brake() {
        // 刹车的行为
    }
    
    public void turn() {
        // 转弯的行为
    }
}

在面向过程编程中,我们将汽车的功能分解为一系列步骤或过程。我们可能会创建不同的函数来执行不同的操作,比如加速函数、刹车函数、转弯函数。每个函数都是独立的,而汽车本身只是数据的集合,没有与这些操作直接相关联。

struct Car {
    char color[20];
    char brand[20];
    char model[20];
};

void accelerate(struct Car* car) {
    // 加速的操作
}

void brake(struct Car* car) {
    // 刹车的操作
}

void turn(struct Car* car) {
    // 转弯的操作
}

在面向对象编程中,重点是对象及其交互,而在面向过程编程中,重点是过程和函数的执行顺序。面向对象编程更具有灵活性和可维护性,因为它更好地模拟现实世界中的实体和关系。而面向过程编程更倾向于简单的线性执行,适用于一些较为简单的任务。

2.类

2.1类的概念

类是用来描述对象(比如说上面的车就是一个对象)的模板和蓝图。

2.2类的定义

定义类使用class关键字,沿用上面的例子

public class Car {
    String color;
    String brand;
    String model;
    
    public void accelerate() {
        // 加速的行为
    }
    
    public void brake() {
        // 刹车的行为
    }
    
    public void turn() {
        // 转弯的行为
    }
}

上面三个是车的属性,叫成员变量,下面三个是车的行为,叫成员方法。这里面包含的内容统称为类的成员。

3.类的实例化

在面向对象编程中,实例化是指根据类的定义创建类的具体对象的过程。当我们实例化一个类时,我们基于类的模板创建了一个具体的对象,该对象具有类中定义的属性和行为。换句话说,实例化是将类转换为对象的过程。在Java中,我们用new关键字来进行类的实例化。
下面继续沿用上面的例子:

public class Car {
    // 属性
    public String color;
    public String brand;
    public String model;


    // 行为
    public void accelerate() {
        // 加速的行为
        System.out.println("加速");
    }

    public void brake() {
        // 刹车的行为
        System.out.println("刹车");
    }

    public void turn() {
        // 转弯的行为
        System.out.println("转弯");
    }
}

这里就定义了一个车类

public class Main {
    public static void main(String[] args) {
        // 创建一辆红色的奔驰轿车对象
        Car myCar = new Car();
        //给车赋予属性
        myCar.brand = "奔驰";
        myCar.color = "红色";
        myCar.model = "轿车";
        // 调用汽车对象的行为
        myCar.accelerate();
        myCar.brake();
        myCar.turn();
    }
}

在主类中 Car myCar = new Car(); 就是对车类的一个实例化。创建了一个新的车,可以给车的属性赋值,也可以使用成员方法,使车进行一些操作。此时打印结果为:
Java——类和对象_第1张图片
注意,可以进行多次实例化
对车类修改,区分一下不同的车

public class Car {
    // 属性
    public String color;
    public String brand;
    public String model;


    // 行为
    public void accelerate() {
        // 加速的行为
        System.out.println(brand + "加速");
    }

    public void brake() {
        // 刹车的行为
        System.out.println(brand + "刹车");
    }

    public void turn() {
        // 转弯的行为
        System.out.println(brand + "转弯");
    }
}

Main类:

public class Main {
    public static void main(String[] args) {
        // 创建一辆红色的奔驰轿车对象
        Car myCar = new Car();
        Car myCar2 = new Car();

        myCar.brand = "奔驰";
        myCar.color = "红色";
        myCar.model = "轿车";
        // 调用汽车对象的行为
        myCar.accelerate();
        myCar.brake();
        myCar.turn();

        myCar2.brand = "宝马";
        myCar2.color = "蓝色";
        myCar2.model = "轿车";
        // 调用汽车对象的行为
        myCar2.accelerate();
        myCar2.brake();
        myCar2.turn();

    }
}

输出:
Java——类和对象_第2张图片

4.this引用

在Java中,this是一个关键字,用于引用当前对象的引用。

4.1 为什么需要this引用

假设有一个Person类,其中有一个实例变量name表示人的姓名,以及一个方法setName用于设置姓名。在这种情况下,如果方法参数和实例变量同名,就需要使用this关键字来区分它们。

public class Person {
    private String name;

    public void setName(String name) {
        // 使用this关键字来引用实例变量,区分方法参数和实例变量
        this.name = name;
    }

    public void printName() {
        System.out.println("Name: " + this.name);
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Alice");
        person.printName();
    }
}

在上面的例子中,setName方法中的参数name与实例变量name同名。在setName方法中,使用this.name来引用实例变量,以明确指示将传入的参数值赋给实例变量。这样可以避免混淆,确保正确地设置实例变量的值。

4.2 this的应用

this主要用于以下方面:

  1. 区分实例变量和局部变量:
    当实例变量和局部变量同名时,使用this关键字来区分。例如:
public class Person {
    private String name;

    public void setName(String name) {
        this.name = name; // this.name引用实例变量,name引用方法参数
    }
}
  1. 在构造方法中调用其他构造方法:
    在一个构造方法中调用同一个类的其他构造方法时,使用this()来实现。例如:
public class Person {
    private String name;
    private int age;

    public Person() {
        this("小明", 30); // 调用另一个构造方法
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
  1. 作为返回值:
    在方法中返回当前对象的引用。例如:
public class Person {
    private String name;

    public Person setName(String name) {
        this.name = name;
        return this;
    }
}
  1. 传递当前对象给其他方法:
    当需要将当前对象传递给其他方法时,可以使用this关键字。例如:
public class Person {
    private String name;

    public void doSomething() {
        OtherClass.processPerson(this);
    }
}

this关键字的使用可以帮助代码更清晰地表达出当前对象的引用,避免混淆和错误。它在实例方法中经常用于引用当前对象的实例变量,以及在构造方法中调用其他构造方法。

5.对象的构造和初始化

5.1 初始化对象

初始化对象的步骤:

  1. 声明类:首先需要声明一个类,描述对象的属性和行为。
  2. 定义构造方法:在类中定义构造方法,用于初始化对象的属性。如果没有显式定义构造方法,Java会提供一个默认的无参构造方法。
  3. 创建对象:使用new关键字和构造方法来创建对象。

5.2 定义构造方法

5.2.1 概念

构造方法(Constructor)是一种特殊类型的方法,在创建类的实例(对象)时用于初始化对象的特定属性。构造方法的名称必须与类名相同,并且没有返回类型(包括void)。在Java中,每个类都可以有一个或多个构造方法,用于初始化对象的状态。

5.2.2 特点

与类同名:构造方法的名称必须与类名完全相同。

没有返回类型:构造方法没有返回类型,包括void。

用于初始化对象:构造方法用于在创建对象时初始化对象的状态,为对象的属性赋初值。

此外:如果在类中没有显式定义任何构造方法,Java会提供一个默认的无参构造方法(默认构造器),用于创建对象。默认构造方法不包含任何参数,且不执行任何操作。

5.2.3 示例

public class Person {
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }

    public static void main(String[] args) {
        // 创建对象并初始化
        Person person = new Person("Alice", 25);
        person.displayInfo();
    }
}

在上面的示例中,Person类包含一个带有两个参数的构造方法,用于初始化name和age属性。在main方法中,我们通过调用构造方法来创建Person对象,并初始化对象的属性。构造方法在对象创建时自动调用,确保对象在创建时具有正确的初始状态。

6. 封装

6.1 封装的概念

封装(Encapsulation)是面向对象编程中的一种重要概念,它指的是将数据(属性)和操作数据的方法(行为)捆绑在一起,并对外部隐藏对象的内部实现细节。封装通过限制对对象的直接访问,提供了更好的控制和安全性,同时提高了代码的可维护性和灵活性。

6.2 访问限定符

在讲封装之前,要先认识访问限定符,java中通过类和访问权限来实现封装。java提供了四种访问限定符。
Java——类和对象_第3张图片
public:
公有访问修饰符,表示对所有类可见。在任何地方都可以访问该成员。
protected:
受保护的访问修饰符,表示对同一包内的类和所有子类可见。在不同包的子类中也可以访问。
default(默认,不使用关键字修饰):
默认访问修饰符,表示对同一包内的类可见。如果不指定访问修饰符,默认为默认访问修饰符。
private:
私有访问修饰符,表示只有在同一类中可见。其他类无法访问私有成员。
示例:

public class Person {
    public String publicName; // 公有成员
    protected int protectedAge; // 受保护成员
    String defaultCity; // 默认访问修饰符,默认包内可见
    private String privatePhoneNumber; // 私有成员

    // 构造方法
    public Person(String name, int age, String city, String phoneNumber) {
        this.publicName = name;
        this.protectedAge = age;
        this.defaultCity = city;
        this.privatePhoneNumber = phoneNumber;
    }

    // Getter和Setter方法
    public String getPrivatePhoneNumber() {
        return privatePhoneNumber;
    }

    public void setPrivatePhoneNumber(String phoneNumber) {
        this.privatePhoneNumber = phoneNumber;
    }
}

在上面的示例中,Person类包含了不同访问修饰符修饰的成员变量。根据不同的访问修饰符,这些成员变量具有不同的可见性和访问权限。

6.3 包

讲到这里,又出现了一个陌生的概念:包。

6.3.1 包的概念

在Java中,包(Package)是一种用于组织类和接口的命名空间。包可以包含类、接口、枚举和注解等Java元素,帮助开发人员组织和管理大型项目中的代码。包的主要作用是避免命名冲突,提供命名空间,以及帮助开发人员更好地组织和管理代码。

6.3.2 包的特点

命名空间:包提供了命名空间,避免了不同类之间的命名冲突,允许在不同包中使用相同名称的类。

访问控制:包可以限制类的访问范围,通过使用不同的访问修饰符来控制包内和包外的访问权限。

组织代码:包可以帮助开发人员更好地组织和管理代码,将相关的类放在同一个包中,提高代码的可维护性。

可重用性:包可以作为代码的单元,方便在不同项目中重用和共享代码。

6.3.3 包的命名规则

包名通常使用小写字母,多个单词用.分隔,例如com.example.myproject。

包名应该是唯一的,通常使用公司域名的倒置形式作为包名的前缀,以确保包名的唯一性。

包名中不应该包含Java保留关键字或特殊字符。

6.3.4 导入包中的类

在Java中,要使用另一个包中的类,需要使用import语句将该类引入到当前的代码文件中。通过import语句,可以告诉编译器在哪里找到所需的类,并且可以使用该类的方法和属性。

  1. 导入单个类:可以使用import语句导入单个类,如
import packageName.className; //自定义包
import java.util.ArrayList;
  1. 导入整个包:可以使用import语句导入整个包,如import packageName.*;。这样可以导入包中的所有类。
    import java.util.*;
  2. 静态导入:如果要导入包中的静态成员(如静态方法、静态变量),可以使用静态导入import static语句。
import static java.lang.Math.*;

下面是个例子:

import java.util.ArrayList; // 导入ArrayList类
import java.util.Collections; // 导入Collections类
import java.util.*; // 导入java.util包中的所有类

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(); // 使用ArrayList类
        list.add("Java");
        list.add("is");
        list.add("fun");

        // 使用Collections类中的方法对集合进行排序
        Collections.sort(list);

        // 遍历集合并输出
        for (String str : list) {
            System.out.println(str);
        }
    }
}

在上面的示例中,我们使用import语句导入了ArrayList类、Collections类以及java.util包中的所有类。通过导入这些类,我们可以在代码中直接使用它们的方法和属性,实现了对包中类的引用和使用。

7. stratic成员

在Java中,static关键字用于创建静态成员,包括静态变量(类变量)和静态方法。静态成员属于类本身,而不是类的实例,因此可以直接通过类名访问,无需创建类的实例。

7.1 静态变量(类变量)

静态变量是使用static关键字声明的变量,它们属于类而不是实例。
所有类的实例共享同一个静态变量的值。
静态变量在类加载时初始化,并且在整个程序的生命周期内存在。

public class MyClass {
    public static int count = 0; // 静态变量

    public static void main(String[] args) {
        MyClass.count++; // 直接通过类名访问静态变量
        System.out.println(MyClass.count); // 输出静态变量的值
    }
}

7.2静态方法

静态方法是使用static关键字声明的方法,可以直接通过类名调用,无需创建类的实例。
静态方法不能直接访问非静态成员,因为在调用静态方法时可能还没有类的实例存在。

public class MathUtil {
    public static int add(int a, int b) { // 静态方法
        return a + b;
    }

    public static void main(String[] args) {
        int sum = MathUtil.add(5, 3); // 调用静态方法
        System.out.println("Sum: " + sum);
    }
}

7.3 静态代码块

这个部分将在下面代码块内容中讲。

8. 代码块

在Java中,代码块是一段包含一组语句的代码块,用于在特定条件下执行一些操作或初始化工作。

8.1 代码块分类

8.1.1 普通代码块

普通代码块是指在方法中使用花括号 {} 包围的一段代码,也称为局部代码块。这种代码块用于限定变量的作用域,使得在代码块外部无法访问在代码块内部声明的变量。普通代码块可以包含任意数量的语句,用于执行特定的操作或逻辑。
示例:

public class LocalBlockExample {
    public static void main(String[] args) {
        int x = 5; // 在代码块外部声明的变量

        {
            int y = 10; // 在普通代码块内部声明的变量
            System.out.println("普通代码块执行");
            System.out.println("x: " + x); // 可以访问外部变量
            System.out.println("y: " + y); // 可以访问内部变量
        }

        // System.out.println(y); // 编译错误,y超出作用域
    }
}

8.1.2 构造代码块

构造代码块(构造块)是在类中使用花括号 {} 包围的一段代码,用于在创建对象时执行初始化操作。构造代码块在类的每次实例化时都会执行,优先于构造方法执行。构造代码块常用于对实例变量进行初始化操作。
构造代码块没有任何参数,不接受任何参数。
构造代码块在每次创建对象时都会执行,优先于构造方法执行。
构造代码块不能被对象直接调用,只能在对象创建时自动执行。

public class ConstructorBlockExample {
    private int x;
    
    // 构造代码块
    {
        System.out.println("构造代码块执行");
        x = 10; // 初始化实例变量
    }

    // 构造方法
    public ConstructorBlockExample() {
        System.out.println("构造方法执行");
    }

    public static void main(String[] args) {
        ConstructorBlockExample obj = new ConstructorBlockExample();
        System.out.println("x的值: " + obj.x);
    }
}

8.1.3 静态代码块

静态代码块(静态初始化块)是在类加载时执行的一段代码块,用于初始化静态变量或执行静态操作。静态代码块使用 static 关键字进行声明,在类加载时只会执行一次,且优先于静态变量的初始化和静态方法的执行。
静态代码块使用 static 关键字声明,不接受任何参数。
静态代码块在类加载时执行,且只会执行一次。
静态代码块用于静态变量的初始化、静态方法的调用以及执行其他静态操作。

public class StaticBlockExample {
    private static int x;

    // 静态代码块
    static {
        System.out.println("静态代码块执行");
        x = 5; // 初始化静态变量
    }

    public static void main(String[] args) {
        System.out.println("x的值: " + x);
    }
}

在上面的示例中,静态代码块用来初始化静态变量 x,并且在类加载时执行,只会执行一次。静态代码块可以用来执行一些静态操作,如静态变量的初始化、静态方法的调用、加载驱动程序等。静态代码块通常用于在类加载时执行一些初始化操作,确保类的静态资源被正确初始化。

9. 内部类

在Java中,内部类是定义在另一个类内部的类。内部类可以访问外部类的成员,包括私有成员,并且可以提供更好的封装和组织代码的方式

9.1 成员内部类

成员内部类是定义在类内部的普通类,可以访问外部类的成员,包括私有成员。

public class Outer {
    private int x;

    class Inner {
        public void display() {
            System.out.println("x的值 " + x);
        }
    }
}

9.2 静态内部类

静态嵌套类是定义在类内部的静态类,与外部类实例无关,可以直接通过外部类名访问。

public class Outer {
    private static int y;

    static class Nested {
        public void display() {
            System.out.println("y的值: " + y);
        }
    }
}

9.3 匿名内部类

匿名内部类是没有类名的内部类,通常用于创建临时的子类或实现接口。这在后面再说。

总结

以上就是类的对象的全部内容,希望大家看完之后,对类和对象有进一步的理解

你可能感兴趣的:(java)