OOP的概念：
面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息
OOP解释：
类和对象
类就像一个蓝图，描述了某种东西的特征和行为。比如，Animal 类是用来描述动物的。
对象就是根据我的 Animal 蓝图，我们可以创建出一个具体的动物， 就是Mao或Cat。就像下面这样
Animal mao = new Mao();
Animal cat = new Cat();
封装
封装就是Animal 类里的 name 和 age 属性是私有的，外面只能通过 getName() 和 setName() 方法来访问和修改。就像这样
// Book 类示例
public class Book {
private String name; // 私有属性
private double price; // 私有属性
// Getter 和 Setter 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
// 其他构造方法和 toString() 方法
}
// Animal 类示例
public class Animal {
private String name; // 私有属性
private int age; // 私有属性
// Getter 和 Setter 方法
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;
}
}
继承
继承允许子类继承父类的属性和方法。举个例子，我的所有物品都由我的儿子王博来继承，像下面Mao 和 Cat 类都继承了 Animal 类，获得了 name 和 age 属性
// Mao 类示例，继承自 Animal
public class Mao extends Animal {
private boolean isEyes; // 新增属性
public Mao(String name, int age, boolean isEyes) {
super(name, age); // 调用父类构造函数
this.isEyes = isEyes;
}
// Getter 和 Setter 方法
}
// Cat 类示例，继承自 Animal
public class Cat extends Animal {
private String tail; // 新增属性
public Cat(String name, int age, String tail) {
super(name, age); // 调用父类构造函数
this.tail = tail;
}
// Getter 和 Setter 方法
}
多态
多态允许使用一个接口或父类的引用来调用子类的方法。在你的 Test 类中，通过 TestService 接口引用 TestServiceImpl 实现类,像下面这样
// Test 类示例
public class Test {
public static void main(String[] args) {
TestService testService = new TestServiceImpl(); // 多态
System.out.println(testService.saySomeThing("123")); // 调用 saySomeThing 方法
}
}
把我的代码放到下面
package cn.zian;
// 父类：动物
public class Animal {
private String name; // 生物的名字
private int age; // 生物的年龄
public Animal() {} // 无参构造方法
public Animal(String name, int age) { // 带参数的构造方法
this.name = name;
this.age = 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;
}
@Override
public String toString() { // 打印信息
return "Animal{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
// 子类：猫（Mao）
public class Mao extends Animal {
private boolean isEyes; // 是否有眼睛
public Mao() {} // 无参构造方法
public Mao(String name, int age, boolean isEyes) { // 带参数的构造方法
super(name, age); // 调用父类构造方法
this.isEyes = isEyes;
}
public boolean isEyes() { // 获取眼睛状态
return isEyes;
}
public void setEyes(boolean eyes) { // 设置眼睛状态
isEyes = eyes;
}
@Override
public String toString() { // 打印毛的信息
return super.toString() + ", Mao{" +
"isEyes=" + isEyes +
'}';
}
}
// 子类：猫（Cat）
public class Cat extends Animal {
private String tail; // 尾巴
public Cat() {} // 无参构造方法
public Cat(String name, int age, String tail) { // 带参数的构造方法
super(name, age); // 调用父类构造方法
this.tail = tail;
}
public String getTail() { // 获取尾巴
return tail;
}
public void setTail(String tail) { // 设置尾巴
this.tail = tail;
}
@Override
public String toString() { // 打印猫的信息
return super.toString() + ", Cat{" +
"tail='" + tail + '\'' +
'}';
}
}
// 测试类
public class Test {
public static void main(String[] args) {
// 创建一个大毛的对象，设置属性
Mao bigMao = new Mao("大毛", 20, true);
System.out.println(bigMao); // 打印大毛的信息
// 使用父类的引用来创建不同的猫对象
Animal mao = new Mao("三毛", 20, false);
Animal cat = new Cat("小猫", 2, "长尾巴");
// 打印三毛和小猫的信息
System.out.println(mao); // 打印三毛的信息
System.out.println(cat); // 打印小猫的信息
}
}
然后他的输出结果如下
Animal{name='大毛', age=20}, Mao{isEyes=true}
Animal{name='三毛', age=20}, Mao{isEyes=false}
Animal{name='小猫', age=2}, Cat{tail='长尾巴'}
