Java之旅（第六章类和对象总结）

6.1 面向对象概述

Java是一种面向对象编程语言，因此理解面向对象编程的基本概念对于学习和理解Java编程语言至关重要。

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将数据和方法组织成对象，这些对象可以相互交互和传递信息。面向对象编程的目的是通过抽象、封装、继承和多态等概念来提高代码的可重用性、可维护性和可扩展性。

在Java中，所有的代码都是写在类（Class）中的。类定义了一个对象的属性和行为，一个Java程序可以包含多个类。每个类都有一个构造函数和多个方法，构造函数用于创建对象，而方法则用于执行操作。

面向对象编程中的三个基本概念是封装、继承和多态：

封装：封装是指将数据和方法隐藏在类的内部，只向外部提供必要的接口。封装可以保护数据不被外部随意修改，提高代码的安全性和可维护性。

继承：继承是指从一个已有的类派生出一个新的类，新类可以继承已有类的属性和方法，并可以新增或修改部分属性和方法。继承可以提高代码的复用性和可扩展性。

多态：多态是指同一个方法可以被不同的对象调用，产生不同的行为。多态可以提高代码的灵活性和可扩展性。

在Java中，还有一些其他的面向对象编程的概念，如抽象类、接口、匿名内部类等，它们都有助于提高代码的复用性和可扩展性。

6.1.1 对象

大雁是一种鸟类，可以把大雁看做是一个类，描述了所有大雁的属性和行为。例如，大雁可以飞行、捕食、繁殖等。而每只具体的大雁，就可以看做是大雁类的一个实例或对象。每只大雁都有自己的体重、翼展、羽毛颜色等属性，也有自己独特的飞行技巧和捕食习惯等行为。

在Java中，同样也可以定义一个鸟类来描述所有鸟类的属性和行为。当需要创建一只大雁对象时，只需要按照鸟类的定义来创建即可。这个大雁对象就拥有了鸟类中定义的所有属性和方法。同时，Java中的对象也支持封装、继承和多态等特性，使得程序更加灵活和易于维护。

6.1.2 类

Java的类就像是一个模板或者蓝图，描述了一类事物的属性和行为。就像一辆汽车需要有品牌、型号、颜色等属性，还需要有加速、刹车、转弯等行为。通过定义一个汽车类，可以描述所有汽车都应该有哪些属性和行为。当需要创建一个具体的汽车对象时，只需要按照汽车类的定义来创建即可，这个对象就有了类中定义的所有属性和行为。通过类的继承和多态特性，可以更方便地扩展和复用代码，使得程序更加灵活和易于维护。在Java中，类是面向对象编程的基础，是实现代码封装、继承和多态的重要手段。

6.1.3 封装

Java的封装是一种面向对象编程的特性，它允许将对象的状态和行为隐藏在对象内部，对外只暴露必要的接口供其他对象访问。这种将对象的状态和行为封装起来的特性被称为信息隐藏或数据隐藏。

在Java中，封装是通过访问修饰符来实现的。通过将属性设置为private，可以将其隐藏在对象内部，防止外部对象直接访问和修改属性的值。而公共的方法可以被其他对象访问，通过这些方法可以访问和修改对象的私有属性，同时还可以对方法进行控制，确保对象状态的合法性和安全性。

Java的封装有助于保护对象的状态不被意外修改，同时也提高了对象的安全性和可维护性。通过封装，对象的实现细节被隐藏起来，使得对象的使用者只需关注对象提供的接口，而无需关心对象内部的具体实现。这使得程序更加模块化，易于维护和扩展。

6.1.4 继承

继承可以用图形类来比喻。在图形类中，基本的形状是一个抽象的概念，包括圆形、矩形、三角形等等。这些基本形状可以被定义为一个父类，其他的形状则是在父类的基础上进行扩展的子类。

例如，椭圆形是图形类中的一种子类，它继承了所有基本形状的属性和方法，并且在此基础上扩展了自己的特点，比如长轴和短轴的长度、面积和周长等等。这些特点让椭圆形在图形类中具有独特的特色，并且能够完成一些其他形状不能完成的任务，比如绘制椭圆形的图形。

Java的继承是面向对象编程中的一种重要特性，它允许创建一个新的类，并从已有的类中继承属性和方法。被继承的类称为父类或超类，新创建的类称为子类或派生类。

在Java中，通过使用extends关键字来实现继承。子类可以继承父类的公共属性和方法，包括其私有属性和方法（但无法直接访问私有属性和方法）。子类还可以扩展或重写父类的方法，从而实现更加特定的功能。

Java的继承提高了代码的重用性和扩展性。通过继承，可以将多个相关的类归纳为一个继承体系，从而提高代码的可维护性和可扩展性。此外，继承还可以使得代码更加易于理解和修改，因为子类的代码可以在父类的基础上进行扩展，而不需要重新编写父类的代码。

6.1.5 多态 

Java的多态是指同一种类型的对象，在不同的情况下有不同的行为表现。它通过继承和重写实现，允许子类继承父类的方法并对其进行重写，以达到不同的实现方式和行为表现。通过多态，可以让代码更加灵活，简洁，易于维护和扩展。

在Java中，多态有三种实现方式：方法重载、方法覆盖和接口实现。其中，方法重载指的是在同一个类中定义多个方法，方法名相同但参数列表不同；方法覆盖指的是子类重新定义父类中已有的方法，方法名和参数列表相同；接口实现指的是实现某个接口中的方法，以达到实现该接口的目的。这三种实现方式都是多态的表现形式。

通过多态，Java可以实现很多高级的特性，如泛型、反射和动态代理等。多态也是面向对象编程的一个重要特征，它允许我们编写出更加灵活、易于扩展和维护的代码。

6.2 类

6.2.1 成员变量 

成员变量（member variable）是指定义在类中，方法外的变量，也称为实例变量（instance variable）或对象属性（object property）。

成员变量与局部变量不同，它们的作用域是整个类，可以被类中的所有方法和构造函数访问。与方法内的局部变量不同，成员变量具有默认初始值。对于基本数据类型的成员变量，其默认初始值为0或0.0；对于引用类型的成员变量，其默认初始值为null。

成员变量可以用修饰符来控制其可见性和访问级别。通常使用private修饰符来限制成员变量的访问范围，使其只能被本类中的方法访问。如果需要对外部提供读取和修改成员变量的方法，可以使用getter和setter方法。

在创建类的对象时，每个对象都会分配自己的一组成员变量，它们的值可以独立地被该对象修改。成员变量的值在对象创建时由构造函数初始化，而在对象销毁时被销毁。

总之，成员变量是类中用来描述对象状态的变量，它们具有类范围的作用域和生命周期。

例题：为书添加书名属性

 6.2.2 成员方法

成员方法是Java中定义在类中的函数，它们用于定义类的行为和操作。每个对象都有自己的一份成员方法，它们可以访问和操作对象的属性，并执行一些操作。

成员方法有以下特点：

1. 成员方法是定义在类中的函数，必须通过类的实例来调用。

2. 成员方法可以访问对象的成员变量和其他成员方法。

3. 成员方法可以有参数和返回值，也可以没有参数和返回值。

4. 成员方法可以是静态的，也可以是非静态的。非静态成员方法必须通过对象来调用，而静态成员方法可以通过类名直接调用。

5. 成员方法可以被重载，即可以定义多个同名但参数列表不同的方法。

通过成员方法，我们可以对对象进行各种操作，比如修改对象的属性，执行某些操作，返回某些结果等。成员方法的使用是面向对象编程的重要特征之一，可以大大提高代码的复用性和可维护性。

 6.2.3 权限修饰符

在Java中，权限修饰符用于限制类、变量和方法的访问权限。Java中有四个权限修饰符：public、protected、default、private。

1. public：公共的，可以被任何类访问。在同一包或不同包的任何地方都可以被调用。

2. protected：受保护的，可以被本类、同一包和子类访问。在同一包的任何地方都可以被调用，在不同包的子类中也可以被调用。

3. default：默认的，如果没有使用任何权限修饰符，则默认为default。可以被本类、同一包的其他类访问，在不同包的类中不可以被访问。

4. private：私有的，只能被本类访问。在同一包或不同包的其他类中都不可以被调用。

权限修饰符的作用是控制访问级别，使得程序更加健壮和安全。

6.2.4 局部变量 

局部变量是在方法、代码块或构造方法中声明的变量，其作用域仅限于该方法、代码块或构造方法中。局部变量必须在声明后初始化才能使用，且不能用访问修饰符修饰。

局部变量在声明时可以不指定初始值，但必须在使用前进行赋值，否则会编译错误。局部变量不具有默认值，因此在使用前必须赋值。

局部变量在声明时不分配内存，只有在方法、代码块或构造方法被调用时才会被分配内存。当方法、代码块或构造方法结束时，局部变量将被销毁，分配给它的内存空间也会被释放。

局部变量可以与成员变量同名，但在方法内使用时，局部变量将覆盖成员变量，此时如果需要访问成员变量，需要使用 this 关键字来指定。

 例题：交换两个整数的值

6.2.5 局部变量的有效范围 

局部变量是在方法或代码块内部声明的变量，只在其声明的方法或代码块内部有效。局部变量可以在声明时进行初始化，也可以在之后的代码中进行初始化。局部变量在方法或代码块执行结束后会被销毁，所以不能被其他方法或代码块访问。局部变量的有效范围从声明开始，到其所在的代码块结束或方法执行结束为止。

 

 6.2.6 this关键字

 this 是一个关键字，用于在一个类的方法中引用当前对象，即该方法被调用时正在操作的对象。this 关键字可以用于访问当前对象的成员变量、成员方法和构造方法。

1.访问成员变量

在方法内部，如果局部变量和成员变量同名，那么使用 this 关键字可以访问成员变量。例如：

public class Person {
    private String name;

    public void setName(String name) {
        this.name = name; // 使用 this 访问成员变量 name
    }
}

2.调用成员方法

在一个成员方法中，可以使用 this 调用当前对象的其他成员方法。例如：

public class Person {
    public void sayHello() {
        System.out.println("Hello!");
    }

    public void greet() {
        this.sayHello(); // 调用当前对象的 sayHello 方法
    }
}

3.调用构造方法

在一个构造方法中，可以使用 this 调用当前类的其他构造方法。例如：

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

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

在上面的例子中，第一个构造方法调用了第二个构造方法，并传递了默认参数 "Unknown" 和 0。

总之，this 关键字是一个很有用的工具，可以方便地访问当前对象的成员变量、成员方法和构造方法，避免了出现歧义和错误。

6.3 类的构造方法

类的构造方法是用于创建对象时被调用的特殊方法，它的名称必须与类名相同，没有返回值类型，并且不能被直接调用。构造方法的主要作用是在对象创建时为对象的成员变量初始化。

构造方法有以下特点：

1.构造方法名必须和类名相同，且没有返回值类型声明。

2.可以有多个构造方法，只要它们的参数列表不同（即构成重载）。

3.如果类没有定义构造方法，Java编译器会默认生成一个无参的构造方法。

4.构造方法可以被重载，即在同一个类中可以有多个构造方法，只要它们的参数列表不同即可。

构造方法的语法格式如下：

public class ClassName {
    // 成员变量
    private String name;
    private int age;
    
    // 构造方法
    public ClassName() {
        // 初始化成员变量
        this.name = "default";
        this.age = 0;
    }
    
    public ClassName(String name, int age) {
        // 初始化成员变量
        this.name = name;
        this.age = age;
    }
    
    // 成员方法
    public String getName() {
        return this.name;
    }
    
    public int getAge() {
        return this.age;
    }
}

在上面的例子中，ClassName类定义了两个构造方法：一个无参的构造方法和一个带有参数的构造方法。无参的构造方法用于创建默认对象，带有参数的构造方法用于初始化对象的成员变量。在构造方法中，使用this关键字来引用当前对象，用于访问对象的成员变量和方法。

例题：“构造”鸡蛋灌饼 

6.4 静态变量和静态方法 

静态变量和静态方法是Java中常用的关键字，可以用于定义和调用属于类的属性和方法。与非静态变量和方法不同，静态变量和静态方法不需要创建类的实例就可以直接访问和调用，因此它们属于类级别的成员。

静态变量（也称为类变量）是指在类中定义的使用static关键字修饰的变量，其在类加载时被初始化，且只被初始化一次，之后即使创建多个类实例也共享同一份静态变量的值。静态变量可以通过“类名.变量名”的方式进行访问。

静态方法（也称为类方法）是指在类中定义的使用static关键字修饰的方法，与静态变量一样，静态方法也是在类加载时被初始化，其调用不需要创建类的实例，可以直接使用“类名.方法名”的方式进行调用。注意，静态方法只能访问静态变量和静态方法，不能访问非静态变量和方法。

使用静态变量和静态方法的注意点：

1.静态变量和静态方法属于类级别的成员，不属于实例级别，因此它们不能访问非静态变量和方法，也不能使用this关键字。

2.静态变量和静态方法可以通过类名直接访问和调用，无需创建类的实例。

3.静态变量在内存中只有一份，被所有类的实例共享，因此修改一个实例的静态变量的值，将会影响到其他所有实例的静态变量的值。

4.静态方法不能被重写，因为它们不属于实例级别，而是属于类级别。如果在子类中定义与父类中同名的静态方法，则相当于是在子类中定义了一个全新的静态方法，与父类中的静态方法无关。

例题：创建并调用静态属性和静态方法

 静态变量：静态变量也称为类变量，它属于类而不是对象，所有该类的实例共享一个静态变量的值。静态变量可以直接通过类名访问，也可以通过对象名访问。声明静态变量时，需要使用static关键字，例如：

public class MyClass {
    static int count = 0;
}

上面的代码中，count是一个静态变量，它的初始值为0。可以直接通过MyClass.count来访问这个静态变量。

静态方法：静态方法也称为类方法，它与静态变量一样属于类而不是对象。静态方法不能访问实例变量，只能访问静态变量和静态方法。声明静态方法时，也需要使用static关键字，例如：

public class MyClass {
    static int count = 0;
    
    public static void incrementCount() {
        count++;
    }
}

上面的代码中，incrementCount()是一个静态方法，它通过count++来增加count的值。可以直接通过MyClass.incrementCount()来调用这个静态方法。

例题：统计顾客总人数

 6.5 类的主方法

类的主方法是Java程序的入口点，也称为main方法。它是一个静态方法，必须声明为public、static和void类型，并且必须有一个String数组类型的参数列表。该方法在程序启动时自动执行，并且可以执行任何Java代码。

在Java中，每个程序必须包含一个类的主方法。主方法通常用于执行应用程序的初始化和设置，以及调用其他类的方法。它可以被其他方法调用，也可以在其他类中使用。主方法的命名必须为main，并且必须按照以下方式声明：

public static void main(String[] args){
    // 主方法的代码逻辑
}

其中，public表示该方法是公共方法，可以从其他类中访问；static表示该方法是静态方法，可以在不创建对象实例的情况下调用；void表示该方法不返回任何值；String[] args是命令行参数的数组，它包含了程序启动时传递给主方法的参数。

在编写程序时，我们通常将主方法放在一个独立的类中，并将该类作为程序的入口点。如果没有主方法，Java编译器无法运行程序。在编写主方法时，需要注意以下几点：

1.主方法必须声明为public、static和void类型，并且必须有一个String数组类型的参数列表。

2.主方法的方法体中可以执行任何Java代码，包括调用其他类的方法。

3.主方法通常用于程序的初始化和设置，以及调用其他类的方法。

4.主方法可以被其他方法调用，也可以在其他类中使用。

5.主方法的命名必须为main。

例题：读取主方法的参数值

6.6 对象 

6.6.1 对象的创建

对象的创建指的是在内存中创建一个类的实例，也称为类的实例化。创建一个对象需要以下步骤：

1.声明对象变量：首先需要声明一个对象变量，声明时需要指定对象的类型。例如，如果要创建一个Student类的实例，需要声明一个Student类型的对象变量。

2.分配内存空间：使用关键字new来为对象分配内存空间。例如，可以使用Student student = new Student()语句来为Student类创建一个新的实例。

3.调用构造方法：创建对象时需要调用构造方法来初始化对象的状态。在Java中，构造方法的名称必须与类名相同。例如，如果要创建一个Student类的实例，就需要调用Student类的构造方法来初始化对象。

4.使用对象：一旦创建了对象，就可以使用对象的方法和属性来完成相应的操作。可以使用对象变量来访问对象的方法和属性。例如，可以使用student.getName()来获取Student对象的名字属性。

在创建对象时需要注意以下几点：

1.对象变量的声明必须指定对象的类型。

2.使用new关键字来为对象分配内存空间时，需要指定对象的类型和使用的构造方法。

3.在Java中，所有的对象都是通过引用来操作的。即使是基本数据类型，也必须通过对象的方式来访问。

例题：创建人类并且创建其对象

6.6.2 访问对象的属性和行为 

访问对象的属性和行为可以通过对象的实例来完成。在Java中，每个对象都有一组属性和行为，其中属性是对象的状态信息，行为则是对象能够执行的操作。通过使用点号（.）访问对象的属性和行为。

例题：描述狗的特征

6.6.3 对象的引用 

对象的引用指的是在程序中使用一个变量来指向一个对象的内存地址，从而可以通过该变量访问该对象的属性和方法。

在Java中，创建一个对象时，会在堆内存中分配一块内存空间，然后返回该对象在内存中的地址。我们可以使用类名后面加括号的方式来创建一个对象，如：Dog myDog = new Dog();，这里就创建了一个Dog类的对象，并将其地址保存在myDog变量中。通过这种方式，我们可以使用myDog变量来引用该对象并调用它的属性和方法。

另外，在Java中对象的引用也可以通过传参的方式进行传递，即将一个对象作为参数传递给方法或构造函数时，实际上传递的是该对象在内存中的地址。这样在方法或构造函数中就可以使用该对象的引用来访问其属性和方法。

6.6.4 对象的销毁

在Java中，对象的销毁是由Java虚拟机自动完成的，无需程序员手动销毁。Java虚拟机在内存管理中使用垃圾回收机制，当一个对象不再被任何引用变量所引用时，Java虚拟机会自动回收该对象所占用的内存空间。也就是说，当程序中没有任何引用变量指向某个对象时，该对象就成为无用对象，等待被垃圾回收器回收。

在垃圾回收的过程中，Java虚拟机会标记所有被引用的对象，并将其保留在内存中，而未被引用的对象会被回收。Java虚拟机会定期执行垃圾回收，以便回收无用对象，释放内存空间。在对象销毁时，Java虚拟机会自动调用对象的finalize()方法，该方法可以在对象被销毁前进行一些必要的清理工作，例如关闭文件、释放网络资源等。

需要注意的是，虽然Java虚拟机自动进行内存管理，但是如果程序员在代码中使用了大量的无用对象，会导致垃圾回收频繁执行，从而影响程序的性能。因此，程序员需要注意控制对象的创建和销毁，尽量避免产生过多的无用对象。可以通过使用对象池、对象复用等技术来降低对象的创建和销毁次数，从而提高程序的性能。

dog的题目

 

 

 

 

结束力！！！高达8360字，这不给我打高分过分了哈