Java 第五天笔记-优快云博客

本文围绕Java面向对象编程展开，介绍了垃圾回收机制、构造函数、重载、static和this关键字等基础知识。重点阐述了面向对象的三大特征：继承、封装和多态。详细说明了封装的优点及实现步骤，不同访问权限修饰符的作用，还通过代码示例展示了多态的实现和子类转换父类的规则。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1 垃圾回收机制

（1）程序员无权调用垃圾回收器

（2）收集并删除未引用的对象。可以通过调用"System.gc()"来触发垃圾回收，但并不保证会确实进行垃圾回收。JVM的垃圾回收只收集哪些由new关键字创建的对象。所以，如果不是用new创建的对象，你可以使用finalize函数来执行清理。

2 构造函数

（1）构造方法的作用：

构造方法作用：对对象进行初始化.

构造函数与普通函数的区别：

（1）. 一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。

（2）. 构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。

（3）. 普通函数可以使用对象多次调用，构造函数就在创建对象时调用。

（4）. 构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。

（5）. 构造函数没有返回值类型。

构造函数要注意的细节：

（1）. 当类中没有定义构造函数时，系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义了构造函数，这时默认的构造函数就没有了。

备注：可以通过javap命令验证。

（2）.在一个类中可以定义多个构造函数，以进行不同的初始化。多个构造函数存在于类中，是以重载的形式体现的。因为构造函数的名称都相同。

.构造代码块：

构造代码块作用：给所有的对象进行统一的初始化。具体作用：

1：给对象进行初始化。对象一建立就运行并且优先于构造函数。

2：与构造函数区别

A：构造代码块和构造函数的区别，构造代码块是给所有对象进行统一初始化，构造函数给对应的对象初始化。

B：构造代码块的作用：它的作用就是将所有构造方法中公共的信息进行抽取。

3 重载

A 方法的重载是指一个类中可以定义名字相同但是参数不同的方法。调用时，会根据不同的参数来调用对应的函数

B：两同三不同：

同一个类，同一个方法名，

不同是：参数列表不同（类型，个数，顺序）

只有返还值不同不构成方法的重载（）如 int a(String sgtr){} ,void a(String i){}

只有形参的名称不同，不构成方法的重载

与普通方法一样。构造方法也可以重载

4 static 关键字（非静态可以调用静态的，但是静态的不可以调用非静态的）

在类中用static 关键字声明的成员变量为静态变量，或者叫做类属性，类变量

：它是该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显示初始化，，对于该类的所有对象来说，static成员变量只有一份。该类的所有对象共享！可以使用对象类属性来调用。不过一般都是使用类名。类属性。static变量至于方法区中。

用static声明方法为静态方法：不需要对象就可以通过(类名.方法名)调用。在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可以访问非static 成员。

5 this关键字（常用于构造方法中（且在一个构造方法中调用另一个构造函数时this(也可以还有参数)：必须在这个构造器的第一行），初始化变量，和set和get方法中）

public Student02(String name,int id){
       this(); //必须位于第一行
       this.name = name; //this.name代指当前对象
       this.id = id;
   }
   public Student02(){
       System.out.println("构造一个对象");
   }

在普通方法中this总是指向调用该方法的对象；在构造函数中this总是指向正要初始化的对象；this不能用于static方法。

6 面向对象三大特征

A:继承：类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。；提高代码的复用性！；extends关键字的意思是扩展，子类是父类的扩展。

子类继承父类，可以得到父类的全部属性和方法（除了父类构造方法）。Java中只有单继承（一个类只有一个直接父类），没有多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。Java的多继承可以通过接口来实现，，如果定义一个类时，没有调用extends，则它的父类是：Java.lang.Object。不同的说法：超类，父类，子类，派生类。

public class Animal {
   String eye;
   public void run(){
       System.out.println("跑");
   }
   public void eat(){
       System.out.println("吃");
   }
   public void sleep(){
       System.out.println("睡");
   }
}
class Mammal extends Animal{
   public void taiSheng(){
       System.out.println("胎生");
   }
}
class Paxing extends Animal{ //
   public void eggSheng(){
       System.out.println("卵生");
   }
}
class Bird extends Animal{

   public void run(){ //重写父类方法(重写后覆盖父类方法)
       super.run(); //super调用父类的方法
       System.out.println("飞");
   }
   public void eggSheng(){
       System.out.println("卵生");
   }
}

继承涉及的方法重写：在子类中可以根据需要对从父类继承的方法进行重写。重写的方法必须和被重写的方法具有相同的方法名称，参数列表和返回值类型。，重写方法不能使用比被重写方法更严格的访问权限。（由于多态）

Object类：该类是所有Java类的根基类

如果在类中声明中未使用extends关键字指明其基类那么该类的基类默认为Object类

public class People{ } 默认继承 public class People extends Object{}

重写：toString方法:默认返回：包名+类名+@+哈希码（根据对象内存位置生成，唯一不重复）。可以重写

封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如

public class Person { private String name; private int age; }这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{

private String name; private int age;

public int getAge(){

return age;

}

public String getName(){

return name;

}

public void setAge(int age){

this.age = age;

}

public void setName(String name){

this.name = name;

}

以上实例中public方法是外部类访问该类成员变量的入口。通常情况下，这些方法被称为getter和setter方法。因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

Java public private protected

（1）访问权限修饰符修饰成员变量和方法
public：表明该成员变量和方法是共有的，能在任何情况下被访问。
protected：必须在同一包中才能被访问，但是对于子类来说即使不同包的子类也可以访问。

default:默认可以在同一个类，同一个包中访问

private：只能在本类中访问。

实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。

（2）访问权限修饰符修饰类
不能用protected和private修饰类

多态：简单的理解就是事物的多种形态。专业的术语说就是：同一个实现接口，使用不同的实例而执行不同的操作。

package zyl.oop.duotai;

public class Animal {
   String string;
   public void voice(){
       System.out.println("普通动物叫声");
   }
}
class Cat extends Animal{
   public void voice(){
       System.out.println("喵喵");
   }
}
class Dog extends Animal{
   public void voice(){
       System.out.println("旺旺");
   }
}
class Pig extends Animal{
   public void voice(){
       System.out.println("哼哼");
   }
}

package zyl.oop.duotai;

public class Test {
   public static void testvoice(Animal a){
       a.voice();
   }
// public static void testvoice(Cat c){
//     c.voice();
// }
// public static void testvoice(Dog d){
//     d.voice();
// }
// public static void testvoice(Pig p){
//     p.voice();
// }
   public static void main(String[] args) {
//       Cat c = new Cat();
//       Animal a = c;
       Animal a = new Cat();//父类的引用指向一个子类对象构成多态
       testvoice(a);
       Animal b = new Dog();
       testvoice(b);
       Animal c = new Pig();
       testvoice(c);
   }