一些关于面向对象编程（OOP）的基础与示例
一，封装
通过将类的成员生命为私有，可以防止外面的代码直接就能访问修改数据，封装也能助力代码的模块化，使代码容易理解和维护,下面是展示封装是如何应用的
```
package cn.lnfvc.qsqm;
public class Book {
private String name; // 书名
private String author; // 作者
private double price; // 价格
private String type; // 类目
// 带参数的构造函数
public Book(String name, String author, double price, String type) {
this.name = name;
this.author = author;
this.price = price;
this.type = type;
}
// 无参构造函数
public Book() {
}
// Getter方法
public String getName() {
return name;
}
public String getAuthor() {
return author;
}
public double getPrice() {
return price;
}
public String getType() {
return type;
}
// Setter方法
public void setName(String name) {
this.name = name;
}
public void setAuthor(String author) {
this.author = author;
}
public void setPrice(double price) {
this.price = price;
}
public void setType(String type) {
this.type = type;
}
// toString方法
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
", type='" + type + '\'' +
'}';
}
}
```
在以上这个例子中，book类的属性都被声明私有（private），让外部代码只能通过getter还有setter方法访问修改这些属性。
二，继承
继承可以减少代码重复，允许创建一个子类继承父类的等等，子类只允许有一个父类，而父类可以拥有很多子类。
只需要用关键字extends就可以指定一个父类完成继承的实现
```
//假设已经有了一个父类之后
public class Cat extends Animal{
//里面是继承的内容
}
```
三，多态
多态意味着一个类的实例可以表现成多种形式。具体来说，多态使得父类的引用可以指向子类的对象，这样就可以通过父类类型的引用调用子类的方法。
为了更好地解释多态，我们将创建一个类 Animal，以及两个继承自 Animal 的子类 Cat 和 Dog。我们还会提供一个方法来演示多态的效果。
Animal 类
```
package cn.lnfvc.qsqm;
public abstract class Animal {
private String name;
private int age;
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;
}
public abstract void makeSound(); // 抽象方法
@Override
public String toString() {
return "Animal{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
```
假设我们已经有了继承了Animal的类Cat和,并实现了其中方法，然后我们使用多态
```
package cn.lnfvc.qsqm;
public class TestAnimal {
public static void main(String[] args) {
Animal cat = new Cat("Whiskers", 2);
makeSound(cat);
}
public static void makeSound(Animal animal) {
animal.makeSound();
}
}
```
四，接口
接口是在面向对象编程中用于定义一组方法签名的规范。接口本身不包含方法的实现，但它规定了实现该接口的类必须提供这些方法的具体实现。接口可以看作是一种合同，确保所有实现该接口的类都遵循相同的契约。
以下是有关接口的代码例子
假设我们有一个TestService接口，它定义了一个名为saySomething的方法
```
package cn.lnfvc.qsqm;
public interface TestService {
String saySomething(String msg);
}
```
这个接口定义了一个方法saySomething，该方法接受一个字符串参数msg，并返回一个字符串,我们需要一个类来实现这个接口。我们创建一个TestServiceImpl类来实现TestService接口。
```
package cn.lnfvc.qsqm;
public class TestServiceImpl implements TestService {
@Override
public String saySomething(String msg) {
return "Ken说" + msg;
}
}
```
最后，我们创建一个测试类Test3来使用TestServiceImpl类，并通过TestService接口引用它
```
package cn.lnfvc.qsqm;
public class Test3 {
public static void main(String[] args) {
TestService testService = new TestServiceImpl();
System.out.println(testService.saySomething("123"));
}
}
```
接口的实现让代码更灵活，具有多态性。
