Java面向对象（封装，继承，多态，接口）

最新推荐文章于 2024-04-29 11:15:46 发布

java_lujj

最新推荐文章于 2024-04-29 11:15:46 发布

阅读量205

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/java_lujj/article/details/126766412

版权

本文详细介绍了Java面向对象的三大特性：封装、继承和多态，以及接口的相关概念。首先讲解了如何创建类和对象，接着探讨了访问控制修饰符（如private和public）以及非访问修饰符如static的作用。然后，深入讨论了继承的类型、特性，以及super和this关键字的使用。此外，文章还涵盖了重写（Override）和重载（Overload）的区别。对于多态，文章阐述了其三个前提条件和优缺点。最后，讲解了抽象类和抽象方法，以及接口的定义、使用及其与类的关系。

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

文章目录

类和对象

首先3个问题：

1. 创建一个类

创建一个学生类，成员变量是姓名和年龄，然后定义构造方法，以及setXxx方法和getXxx方法，分别来赋值和获取。

public class Student {
 
    // 定义成员变量
    private String name;
    private int age;
    
    // 空参构造函数
    public Student()
    {
 
    }
    // 有参构造函数
    public Student(String name,int age)
    {
 
        this.name = name;
        this.age = age;
    }
    
    /*
    // 针对每一个私有化变量，都要提供get和set方法
    // set方法：给成员变量赋值
    // get方法：对外提供成员变量的值
    */
    
    // 给成员变量name进行赋值
     public void setName(String name)
    {
 
        this.name = name;
    }
    // 对外提供name属性的值
    public String getName()
    {
 
        return this.name;
    }
    
     // 给成员变量age进行赋值
    public void setAge(int age) {
 
        this.age = age;
    }
    // 对外提供age属性的值
    public int getAge() {
 
        return age;
    }
}

举的例子其实就是个 标准的javabean类 （javabean类：用来描述一类事物的类，不需要写main方法，IDEA中快捷键是 Alt+Insert ）

2. 创建一个对象

public class StudentTest{
 
   public static void main(String[] args){
 
      // 创建一个Student类对象
      Student std1 = new Student();
      //创建一个带参数的Student类对象
      Student std2 = new Student("zangsan",23);
   }
}

3. 访问变量和方法

public class StudentTest{
 
   public static void main(String[] args){
 
      // 创建一个Student类对象
     Student std = new Student();
     std.setName("lisi");
     std.setAge(24);
     
     String name = std.getName();
     int age = std.getAge();
     System.out.println(”姓名：“+name+” “+”年龄：“+age)
   }
}

some tips：

（1）构造方法

以三个问题回顾一下构造方法：

Q	A
构造方法的作用?	创造对象的时候，由虚拟机自动调用，给成员变量进行初始化的
构造方法有几种?	无参构造方法：初始化的对象时，成员变量的数据均采用默认值。有参构造方法：在初始化对象的时候，同时可以为对象进行赋值。
构造方法的注意事项?	（1）任何类定义出来，默认就自带了无参数构造器（2）定义了有参构造器，无参数构造器就没有了（3）建议在任何时候都手动写上空参和带全部参数的构造方法

（2）this关键字

可以 区分成员变量和局部变量 ，与python中的self相似；

代表方法调用者的地址。

this的内存原理如下：

（3）private关键字

private关键字是一个权限修饰符，可以修饰成员（成员变量和成员方法）；
被private修饰的成员 只能在本类中才能访问 ；
针对private修饰的成员变量，如果需要被其他类使用，提供相应操作，如：提供setXxx(参数)方法**，用于给成员变量赋值，方法用public修饰；提供 getXxx()方法 ，用于获取成员变量的值，方法用public修饰。

面向对象三大特性：封装，继承，多态。

原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为

如何实现封装？

修改属性的可见性，在属性的前面添加修饰符 (private)
对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问
在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定

1.访问控制修饰符

在实际中，一般只用 private 和 public ，按照 成员变量私有 ， 方法公开的原则

2.非访问修饰符

分为静态变量和静态方法

静态变量：

static 关键字用来声明 独立于对象 的静态变量。无论一个类实例化多少对象，它的静态变量只有一份拷贝，也就是说被该类 所有对象共享 ，静态变量也被称为 类变量 。可以直接通过类名调用。
静态方法：

static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

具体可以看下图：

（工具类：帮助我们做一些事情，但是不具体描述任何事物的类

特点：类名知名见意；私有化构造方法）

最后说一下static的注意事项

而main函数的修饰符static，其实也是一样的道理

final 修饰方法：表明该方法是最终方法，不能被重写；
final 修饰类：表明该类是最终类，不能被继承；
final 修饰变量：即常量，只能被赋值一次。

注意：

final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
final修饰的变量是 引用类型 ：那么变量存储的 地址值不能发生改变 ，对象内部的可以改变。

关键词：extend

class 父类 {
 
}
 
class 子类 extends 父类 {
 
}

1.继承的类型

（1）多重继承（直接父类，间接父类）

代码：

class B extends A{
 
}

class C extends B{
 
}

（2）不同类继承同一个类（一个父亲可以有多个儿子）

代码：

class B extends A{
 
}

class C extends A{
 
}

（3）多继承不支持，即 一个类继承两个类不支持 （一个儿子不能有两个爸爸）

总结一下：

Java只能单继承：一个类只能继承自 一个直接父类 （每个类只有一个爸爸）。
Java不支持多继承、但是支持多重继承（爷父子三代）。
Java中所有的类都 直接或者间接 继承于Object类。（所有类都有爸爸）

2.继承的特性

（1）子类拥有父类 非 private 的属性、方法 。

（2）子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

（3）子类可以用自己的方式实现父类的方法。

子类能 继承父类的哪些内容 ？

注意：

（1）private的私有变量虽然可以继承，但是子类不能使用

（2）虚方法表：父类会将“经常用的方法”放入虚方法表中，并且这些方法是 非private，非static，非final的 。然后子类继承后，会在父类基础上添加自己类的虚方法。

3.继承中的访问特点：

this调用：就近原则；super调用：直接找父类

(1）成员变量：就近原则

先在局部位置找——本类成员位置找——父类成员位置找，逐级往上。

如果子类父类中出现 不重名 的成员变量，这时的访问是 没有影响的

子父类中出现了同名的成员变量时，子类会 优先访问 自己对象中的成员变量

（2）成员方法：与成员变量类似，也是就近原则

（3）构造方法：

super

eg：

// 创建一个Person类
class Person()
{
 
   private String id;
   private String name;

  public Person(String id,String name)
  {
 
  this.id = id;
  this.name = name;
  }
}
// 创建一个Student类，继承自Person类
class Student extends Person()
{
 
	private String gender;
	public Student(String id,String name,String gender)
	{
 
	super(id,name);
	this.gender = gender;
	} 
}

4.super&this

super关键字：我们可以通过super关键字来实现 对父类成员的访问 ，用来引用当前对象的父类。

this关键字：指向 自己的引用 。

具体地：

super 关键字在子类内部使用，代表父类对象。

访问父类的属性 super.属性名。
访问父类的方法 super.bark()。
子类构造方法需要调用父类的构造方法时

5.重写（Override）&重载（Overload）

重写（Override）：

是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。 即外壳不变，核心重写！

重写的 好处在于 子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

特点：

（1）重写方法的 名称、形参列表 必须与父类中的一致。

（2）子类重写父类方法时，访问权限子类必须大于等于父类

（3）子类重写父类方法时，返回值类型子类必须小于等于父类

（4）建议 :重写的方法尽量和父类保持一致。

（5）只有被添加到 虚方法表 中（ 前面说的三个非 ）的方法才能被重写

重载(overload)

在一个类里面， 方法名字相同，而参数不同 。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；

总结一句话：

重写是 父类与子类之间多态性 的一种表现，重载可以理解成 一个类多态 的具体表现形式。

同一个事件发生在不同的对象上会产生不同的结果（或者说是同类型的对象，表现出的不同形态）

1.三个前提条件

有继承/实现关系
有 父类引用指向子类对象 ， Fu fu = new Zi()
有方法重写

通俗地讲，多态就是只通过父类就能够引用不同的子类

2. 多态中调用成员变量的特点

调用成员变量：编译看左边，运行也看左边

编译看左边: javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
运行也看左边: java运行代码的时候，实际获取的就是 左边父类中成员变量的值

调用成员方法：编译看左边，运行看右边

编译看左边:javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
运行看右边: java运行代码的时候， 实际上 运行的是 子类中的方法 。

简单理解一下：

Animal a = new Dog();

// 现在 a 去调用变量和方法，a 是 Animal 类型的，所以会默认从 Animal 类中找

成员变量:在子类的对象中，会把父类的成员变量也继承下来；

成员方法：如果子类对方法进行了重写，那么在虚方法表中会把父类的方法进行覆盖。

即成员方法有重写，但成员变量没有，所以两者的访问不一样。

3.多态的优缺点

好处：

（1）右边对象可以解耦，便于拓展和维护

Animal a = new Dog();
a.eat(); // 业务逻辑发生改变时，后续代码无需改变

（2）使用父类型作为参数，可以 接收所有子类对象 ，体现多态的拓展性和便利性

弊端

（1）不能调用子类的独有方法

如果需要调用该怎么办？

引用数据类型的类型转换——向下转型

Animal a = new Dog();
Dog d = (Dog) a;

这样转换成了真正的子类类型，从而可以调用 子类的独有功能 。（转换类型与真实对象类型不一致会报错）

所以更多时候，可以加一个判断语句： instanceof

public static void show(Animal a)
{
 
        a.eat();
        // 类型判断
        if (a instanceof Cat)  {
   // 猫做的事情 
            Cat c = (Cat)a;
            c.catMouse();
        } else if (a instanceof Dog) {
  // 狗做的事情 
            Dog c = (Dog)a;
            c.lookHouse();
        }
}

抽象类和抽象方法

抽象方法：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。
抽象类：一个类中没有包含足够的信息来描绘一个具体的对象。如果一个类中 存在抽象方法 ，那么该类 就必须声明为抽象类 。

2.定义格式——abstract

抽象方法只包含一个方法名，而没有方法体，方法名后面 直接跟一个分号 ，而不是花括号；

抽象类同样也用 abstract 修饰

//抽象方法
public abstract 返回值类型 方法名（参数列表）;

//抽象类
public abstract class 类名{
 }

3. 特性

抽象类不能实例化，所以抽象类 必须被继承
抽象类中不一定有抽象方法， 有抽象方法的类一定是抽象类 ，可以有构造方法
抽象类的子类：要么 重写抽象类中的所有抽象方法 ；要么是抽象类

4.举个栗子

// 父类,抽象类
abstract class Employee {
 
	private String id;
	private String name;
	
	public Employee() {
 
	}
	
	public Employee(String id, String name) {
 
		this.id = id;
		this.name = name;
	}
	
	// 抽象方法必须要放在抽象类中
	public abstract void work();
}

// 定义一个子类继承抽象类
class Manager extends Employee {
 
	public Manager() {
 
	}
	public Manager(String id, String name) {
 
		super(id, name);
	}
	
	@Override 重写父类的抽象方法
	public void work() {
 
		System.out.println("管理其他人");
	}
}

// 定义一个子类继承抽象类
class Cook extends Employee {
 
	public Cook() {
 
	}
	public Cook(String id, String name) {
 
		super(id, name);
	}
	@Override
	public void work() {
 
		System.out.println("厨师炒菜多加点盐...");
	}
}

1.什么是接口

首先为什么要有接口？

从下图可以看出，动物类按照之前讲的，可以定义为抽象类，里面有“吃饭喝水”抽象方法，这时下面的子类都需要重写这两个方法。但是，”游泳“方法只有“青蛙和狗类”可以重写，所以将其定义为一个接口。

什么是接口？

接口用于 描述类所具有的功能 ，而 不提供功能的实现 。
接口中的方法是抽象方法（没有方法体）
接口中的方法体需要写在实现接口的类中，并且该类 必须实现 接口中所有抽象方法。（除非实现接口的类是抽象类）
接口 不能实例化 ，没有构造函数

2.如何定义和使用一个接口

定义一个接口——interface：

// 关键字：interface
public interface A{
  }

使用(实现)一个接口——implements:

// 关键字：implements
public class C implements A{
 }

注：接口的继承：可以单继承，也可以多继承

单继承：

public interface Sports
{
 
   public void setHomeTeam(String name);
}
// 文件名: Football.java
public interface Football extends Sports
{
 
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
}

此时当类实现Football接口时，需要实现它及它的父接口的所有方法,所以共需要实现2+1=3个方法

多继承：

public interface inter1
{
 
   public void method1();
}

public interface inter2
{
 
   public void method2();
}

public interface inter3 extends inter1,inter2
{
 
   public void method3();
}

那么，在类实现接口inter3的时候，需要重写所有抽象方法（1+1+1=3个）

3.接口里成员的特点

成员变量：只能是常量，会被隐式的指定为 public static final 变量
成员方法： 隐式抽象 的,接口中的方法会被隐式的指定为 public abstract
构造方法：没有

注意：

JDK 1.8 以前：接口只能定义抽象方法

JDK 1.8 以后：接口中可以定义有方法体的方法；

JDK 1.9 以后：接口中可以定义私有方法

eg.

// 定义接口A，提供eat方法接口，抽象方法
public interface A{
 
   
	public abstract void eat();
}
// 定义接口 B，提供 sleep 方法接口，抽象方法
public interface B{
 
	public abstract void sleep();
}
//定义类 C 实现 A，B 方法的接口
public class C implements A,B{
 
	public void eat()
	{
 
	   System.out.println("吃饭");
	}
	public void sleep()
	{
 
	  System.out.println("睡觉");
	}
}