Java 中的 OOP 概念
面向对象编程(OOP)是一种结构化的软件开发方法。在 Java 中,四个核心原则定义了面向对象编程。它们包括:
- 抽象(Abstraction)
- 封装(Encapsulation)
- 继承(Inheritance)
- 多态(Polymorphism)
1. 抽象(Abstraction)
抽象是指隐藏复杂实现的细节,只向用户展示必要的信息。在 Java 中,抽象通过接口和抽象类来实现。
接口(Interface)
接口是一种仅包含方法签名的容器,不包含数据成员和方法的实现。使用接口可以减少代码的复杂性,提高代码的可读性。
语法:
java
<访问修饰符> interface <接口名> {
<方法签名>;
}
示例:
java
package simplilearn;
public interface Area {
public void Square();
public void Circle();
public void Rectangle();
public void Triangle();
}
package simplilearn;
import java.util.Scanner;
public class ShapeArea implements Area {
@Override
public void Circle() {
Scanner kb = new Scanner(System.in);
System.out.println("输入圆的半径");
double r = kb.nextDouble();
double areaOfCircle = 3.142 * r * r;
System.out.println("圆的面积是: " + areaOfCircle);
}
@Override
public void Square() {
Scanner kb2 = new Scanner(System.in);
System.out.println("输入正方形的边长");
double s = kb2.nextDouble();
double areaOfSquare = s * s;
System.out.println("正方形的面积是: " + areaOfSquare);
}
@Override
public void Rectangle() {
Scanner kb3 = new Scanner(System.in);
System.out.println("输入矩形的长度");
double l = kb3.nextDouble();
System.out.println("输入矩形的宽度");
double b = kb3.nextDouble();
double areaOfRectangle = l * b;
System.out.println("矩形的面积是: " + areaOfRectangle);
}
@Override
public void Triangle() {
Scanner kb4 = new Scanner(System.in);
System.out.println("输入三角形的底边");
double base = kb4.nextDouble();
System.out.println("输入三角形的高");
double h = kb4.nextDouble();
double areaOfTriangle = 0.5 * base * h;
System.out.println("三角形的面积是: " + areaOfTriangle);
}
public static void main(String[] args) {
ShapeArea geometry = new ShapeArea();
geometry.Circle();
geometry.Square();
geometry.Rectangle();
geometry.Triangle();
}
}
抽象类(Abstract Class)
抽象类类似于接口,但不同的是,抽象类可以包含数据成员和方法的实现。
语法:
java
<访问修饰符> abstract class <类名> {
<数据成员>;
<方法>;
}
示例:
java
package Simplilearn;
public abstract class Person {
private String name;
private String gender;
public Person(String name, String gender) {
this.name = name;
this.gender = gender;
}
public abstract void work();
@Override
public String toString() {
return "Name=" + this.name + ", Gender=" + this.gender;
}
public void changeName(String newName) {
this.name = newName;
}
public void exam() {
// 方法实现
}
}
package abstraction;
public class Employee extends Person {
private int empId;
public Employee(String name, String gender, int empId) {
super(name, gender);
this.empId = empId;
}
@Override
public void work() {
System.out.println("员工正在工作");
}
public static void main(String[] args) {
Person employee = new Employee("张三", "男", 1094826);
employee.work();
employee.changeName("李四");
System.out.println(employee.toString());
}
}
2. 封装(Encapsulation)
封装是指将数据成员和方法绑定在一起,并将它们声明为私有,以保护对象的内部状态。
语法:
java
<访问修饰符> class <类名> {
private <数据成员>;
private <方法>;
}
示例:
java
package Simplilearn;
public class Emp {
public static void main(String[] args) {
Encapsule emp = new Encapsule();
emp.setName("Robert");
System.out.println(emp.getName());
}
}
package Simplilearn;
public class Encapsule {
private String empName;
public String getName() {
return empName;
}
public void setName(String empName) {
this.empName = empName;
}
}
3. 继承(Inheritance)
继承是 OOP 中简化软件开发的一种方法。它允许通过继承已定义类的数据成员和方法来创建新的类。
继承的类称为子类或派生类,被继承的类称为父类或基类。继承可以通过多种方式实现。
单继承(Single Inheritance)
单继承包含一个父类和一个子类。子类继承父类的方法和数据成员。
示例:
java
package inheritance;
class Student {
void play() {
System.out.println("踢足球...");
}
}
class Bob extends Student {
void study() {
System.out.println("学习物理...");
}
}
public class Single {
public static void main(String[] args) {
Bob bob = new Bob();
bob.study();
bob.play();
}
}
多级继承(Multi-Level Inheritance)
多级继承也是父类-子类的关系,但不同的是,另一个子类继承前一个子类。
示例:
java
package inheritance;
class Bike {
public Bike() {
System.out.println("排量: 1000cc");
}
public void bikeType() {
System.out.println("车型: 运动型");
}
}
class Ninja extends Bike {
public Ninja() {
System.out.println("型号: Ninja");
}
public void brand() {
System.out.println("制造商: Kawasaki");
}
public void speed() {
System.out.println("最高速度: 290公里/小时");
}
}
public class Ninja1000R extends Ninja {
public Ninja1000R() {
System.out.println("型号: 1000R");
}
@Override
public void speed() {
System.out.println("最高速度: 280公里/小时");
}
public static void main(String[] args) {
Ninja1000R obj = new Ninja1000R();
obj.bikeType();
obj.brand();
obj.speed();
}
}
多重继承(Multiple Inheritance)
Java 不支持多重继承,因为它会导致严重的歧义问题。接口可以解决菱形问题。
层次继承(Hierarchical Inheritance)
层次继承是一种父类-子类关系,不同的是,多个子类继承同一个父类。
示例:
java
package inheritance;
class Employee {
double leaves = 25.00;
}
class PEmployee extends Employee {
float totalHoursPerDay = (float) 8.00;
}
class TEmployee extends Employee {
float totalHoursPerDay = (float) 10.50;
}
public class EmployeeSalary {
public static void main(String[] args) {
PEmployee permanent = new PEmployee();
TEmployee temporary = new TEmployee();
System.out.println("正式员工总假期数: " + permanent.leaves);
System.out.println("正式员工每天工作小时数: " + permanent.totalHoursPerDay);
System.out.println("临时员工总假期数: " + temporary.leaves);
System.out.println("临时员工每天工作小时数: " + temporary.totalHoursPerDay);
}
}
混合继承(Hybrid Inheritance)
混合继承可以是单继承、多级继承和层次继承的组合。
示例:
java
package inheritance;
class C {
public void print() {
System.out.println("C 是所有 A, B, D 的父类");
}
}
class A extends C {
@Override
public void print() {
System.out.println("A 与 C 有单继承关系,并与 B 共享层次结构");
}
}
class B extends C {
@Override
public void print() {
System.out.println("B 与 C 有单继承关系,并与 A 共享层次结构");
}
}
public class D extends A {
@Override
public void print() {
System.out.println("D 与 A 有单继承关系,并与 C 有多级继承关系");
}
public static void main(String[] args) {
A w = new A();
B x = new B();
C y = new C();
D z = new D();
y.print();
w.print();
x.print();
z.print();
}
}
HAS-A 关系
当一个类继承另一个类的实例或其自身的实例时,这种关系称为 HAS-A 关系。
示例:
java
package inheritance;
class School {
private String name;
School(String name) {
this.name = name;
}
public String schoolName() {
return this.name;
}
}
class Student {
private String name;
Student(String name) {
this.name = name;
}
public String studentName() {
return this.name;
}
}
public class HasARelation {
public static void main(String[] args) {
School schl = new School("St.John's School");
Student candidate = new Student("Tobey Marshall");
System.out.println(candidate.studentName() + " 是 " + schl.schoolName() + " 的前学生");
}
}
IS-A 关系
当一个类继承其他类的方法和成员时,这种关系称为 IS-A 关系。
示例:
java
package inheritance;
import java.util.*;
class Customer {
public String name;
public String city;
Customer(String name, String city) {
this.name = name;
this.city = city;
}
}
class Bank {
private final List<Customer> customers;
Bank(List<Customer> customers) {
this.customers = customers;
}
public List<Customer> totalAccountsInBank() {
return customers;
}
}
public class IsARelation {
public static void main(String[] args) {
Customer C1 = new Customer("Raju", "Bangalore");
Customer C2 = new Customer("Shiva", "Hyderabad");
Customer C3 = new Customer("Sachin", "Mumbai");
Customer C4 = new Customer("Prashanth", "Vizag");
Customer C5 = new Customer("John", "Goa");
List<Customer> customers = new ArrayList<>();
customers.add(C1);
customers.add(C2);
customers.add(C3);
customers.add(C4);
customers.add(C5);
Bank ABCBank = new Bank(customers);
List<Customer> cust = ABCBank.totalAccountsInBank();
for (Customer cst : cust) {
System.out.println("客户姓名: " + cst.name + "\n" + "城市: " + cst.city);
}
}
}
4.多态(Polymorphism)
多态是指一个对象可以有多种形态的能力。在 Java 中,多态主要通过方法重载(Overloading)和方法重写(Overriding)来实现。
方法重载(Method Overloading)
方法重载是指在一个类中定义多个同名方法,但方法的参数列表不同。
示例:
java
package polymorphism;
public class Addition {
public int add(int x, int y) {
return (x + y);
}
public double add(double d, double e, double f, double g) {
return (d + e + f + g);
}
public double add(double a, double b) {
return (a + b);
}
public static void main(String[] args) {
Addition a = new Addition();
System.out.println(a.add(25, 30));
System.out.println(a.add(10.0, 15.0, 20.0, 25.0));
System.out.println(a.add(127.5, 123.5));
}
}
方法重写(Method Overriding)
方法重写是指子类重新实现父类中的方法。
示例:
java
package polymorphism;
public class SuperKeyword {
public static void main(String[] args) {
Triangle two = new Triangle();
two.countSides();
}
}
class Square {
int sides = 4;
}
class Triangle extends Square {
int sides = 3;
public void countSides() {
System.out.println("正方形的边数: " + sides);
System.out.println("三角形的边数: " + super.sides);
}
}
静态多态性和动态多态性
- 静态多态性(编译时多态性):在编译阶段执行,方法重载是典型的静态多态性。
- 动态多态性(运行时多态性):在程序执行阶段处理,方法重写是典型的动态多态性。
总结
Java 是一种广泛使用的面向对象编程语言,其核心概念围绕着四个基本原则:抽象(Abstraction)、封装(Encapsulation)、继承(Inheritance)和多态(Polymorphism)。下面是对这些概念的详细总结:
1. 抽象(Abstraction)
- 定义:抽象是指隐藏复杂的实现细节,只向用户展示必要的信息。
- 实现方式 :
- 抽象类 :使用
abstract
关键字定义的类,可以包含抽象方法(没有实现的方法)。 - 接口 :使用
interface
关键字定义的完全抽象类,所有方法都是抽象的。
- 抽象类 :使用
示例:
java
abstract class Animal {
abstract void makeSound();
}
interface Flyable {
void fly();
}
2. 封装(Encapsulation)
- 定义:封装是指将数据成员和方法绑定在一起,并将它们声明为私有,以保护对象的内部状态。
- 实现方式 :
- 访问修饰符 :使用
private
、protected
和public
控制类成员的访问权限。 - getter 和 setter 方法:提供方法来访问和修改私有成员。
- 访问修饰符 :使用
示例:
java
class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
3. 继承(Inheritance)
- 定义:继承是 OOP 中简化软件开发的一种方法。它允许通过继承已定义类的数据成员和方法来创建新的类。
- 实现方式 :
- 单继承:一个类只能继承一个父类。
- 多级继承:一个类可以继承另一个类,后者又可以继承另一个类。
- 层次继承:多个类可以从同一个父类继承。
- 混合继承:结合单继承、多级继承和层次继承。
示例:
java
class Animal {
void eat() {
System.out.println("Animal eats");
}
}
class Dog extends Animal {
void bark() {
System.out.println("Dog barks");
}
}
class Puppy extends Dog {
void weep() {
System.out.println("Puppy weeps");
}
}
4. 多态(Polymorphism)
- 定义:多态是指一个对象可以有多种形态的能力。在 Java 中,多态主要通过方法重载(Overloading)和方法重写(Overriding)来实现。
- 实现方式 :
- 方法重载(Overloading):在一个类中定义多个同名方法,但方法的参数列表不同。
- 方法重写(Overriding):子类重新实现父类中的方法。
示例:
java
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
@Override
void sound() {
System.out.println("Cat meows");
}
}
public class PolymorphismDemo {
public static void main(String[] args) {
Animal myAnimal = new Animal();
Animal myDog = new Dog();
Animal myCat = new Cat();
myAnimal.sound(); // Animal makes a sound
myDog.sound(); // Dog barks
myCat.sound(); // Cat meows
}
}