20%的功能满足80%的需求。爱、喜悦、和平。
一、理论基础
什么是类？
类是对一组对象的抽象
子类和父类的关系？
父类和子类，顾名思义，它们就是老子和儿子，有着父子关系。而这里指的父子关系，其实也就是一种包含关系。
打个比方，在我们现实生活中，学生Student是一个很大的概念，而 UStudent大学生是属于学生中的一种，这里的学生即为父类，大学生即为子类。
那到底父类和子类区别在哪呢？打个比方，学生和大学生都会有学习Study这个方法，但是大学生还会有自己特有的Study方法，两者还是有一定区别的，大学生的学习相较于其他学生来说，是更自由的。
假如现在我已经有了一个Student类，然后我还要写一个UStudent类，然后UStudent类里有很多方法和Student里的方法都相同，但是还是有一小部分不同，这时问题就出现了，怎样去解决呢？难道又重新来写一个大学生类，并且重复敲一遍和学生类中一样的代码吗？那样浪费了时间和精力，并且浪费了存储空间，是很不划算的。于是乎，我们就想到了继承。
子类继承父类，顾名思义，就是子类能引用父类中的某些东西。继承的关键字是extends，用几行代码说明下怎么去继承。
eg.public class Student(){}//父类
public class UStudent extends Student(){}//子类继承了父类
刚才上面说了当子类和父类用一个同名方法，但是子类的实现却和父类不同、有其特殊性时，用到方法的重写。重写是指方法定义相同，但是实现不同，存在于父子类之间。
eg.
//父类
public class Student(){
//学习方法
public void study(){
System.out.println("我通过听老师讲课学习");
}
}
//子类
public class UStudent extends Student(){
public void study(){
System.out.println("我通过自习去学习");
}
}
什么是抽象？
面向对象软件开发的一个基本方法就是抽象，到底什么是抽象呢? 抽象是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征。例如苹果、香蕉、生梨、葡萄、桃子等，它们共同的特性就是水果。得出水果概念的过程，就是一个抽象的过程。要抽象，就必须进行比较，没有比较就无法找到共同的部分。 共同特征是指那些能把一类事物与他类事物区分开来的特征，这些具有区分作用的特征又称本质特征。因此抽取事物的共同特征就是抽取事物的本质特征，舍弃不同特。所以抽象的过程也是一个裁剪的过程，不同的、非本质性的特征全部裁剪掉了。 所谓的共同特征，是相对的，是指从某一个刻面看是共同的。比如，对于汽车和大米，从买卖的角度看都是商品，都有价格，这是他们的共同的特征，而从其他方面来比较是，他们则是不同的。所以在抽象时，同与不同，决定于从什么角度上来抽象。抽象的角度取决于分析问题的目的。 在软件开发过程中，识别稳定的需求、识别核心的需求、识别概念性的需求、设计系统的架构、定义系统中构件之间的接口关系等等都是抽象的过程，都是反应系统的本质特征的过程。 抽象的，才是稳定的，才是永恒的。 抽象的反义词是具体。人员往往会说：“你讲的太抽象了，能不能讲的具体一点?”在开发语言中，有抽象类，有具体类，具体类可以继承自抽象类，可以实例化。抽象类可以派生出众多的不同的具体类。所谓：“一生二，二生三，三生万物”。系统的稳定体现在抽象类，系统的变化体现在具体类。抽象类的层次要高于具体类。 系统因抽象而稳定，因抽象而生动。
什么是封装？
传统意义上：就是对数据的隐藏。
其实不仅仅是数据的隐藏，还包括内部的方法、实现的细节，引用的其他的类等的隐藏。
简单来说，就是把变量分别用get和set方法写出来，例如：
public class Room {
private int room_id; //餐台编号
private String room_type; //餐台类型
private float room_money; //收费类型
public int getRoom_id() {
return room_id;
}
public void setRoom_id(int roomId) {
room_id = roomId;
}
public String getRoom_type() {
return room_type;
}
public void setRoom_type(String roomType) {
room_type = roomType;
}
public float getRoom_money() {
return room_money;
}
public void setRoom_money(float roomMoney) {
room_money = roomMoney;
}
}
什么是继承？接口？
假如现在我已经有了一个Student类，然后我还要写一个UStudent类，然后UStudent类里有很多方法和Student里的方法都相同，但是还是有一小部分不同，这时问题就出现了，怎样去解决呢？难道又重新来写一个大学生类，并且重复敲一遍和学生类中一样的代码吗？那样浪费了时间和精力，并且浪费了存储空间，是很不划算的。于是乎，我们就想到了继承。
子类继承父类，顾名思义，就是子类能引用父类中的某些东西。继承的关键字是extends，用几行代码说明下怎么去继承。
eg.public class Student(){}//父类
public class UStudent extends Student(){}//子类继承了父类
刚才上面说了当子类和父类用一个同名方法，但是子类的实现却和父类不同、有其特殊性时，用到方法的重写。重写是指方法定义相同，但是实现不同，存在于父子类之间。
eg.
//父类
public class Student(){
//学习方法
public void study(){
System.out.println("我通过听老师讲课学习");
}
}
//子类
public class UStudent extends Student(){
public void study(){
System.out.println("我通过自习去学习");
}
}
接下来我们再来说说接口。
接口
比如，我们要画图形，LINE、OVAL、RECT等都继承自DrawImage类，但是每个子类画图的方法都是完全不一样的，此时，父类里面不需要有什么具体实现就行。这时，接口出现了。
它的作用就是给其他类继承(这里用到一个特殊的关键字：interface，是特殊的继承)，让其他类实现里面很抽象的方法。
eg.
//接口里的方法都是抽象的，没有方法体；属性都是常量；不能实例化一个对象
public interface DrawImage(){
public void draw();
}
public class LINE implements DrawImage(){
public void drawLine(){
System.out.println("draw a line");
}
}
public class OVAL implements DrawImage(){
public void drawOval(){
System.out.println("draw a oval");
}
}
public class LINE implements DrawImage(){
public void drawRect(){
System.out.println("draw a rect");
}
}
什么是多态？
在父类和子类中还有个很重要的概念，转型。分为强制转型和自动转型，这里我们主要讲解
自动转型。父类对象是可以自动转型为子类对象的，然后直接调用子类中已重写的方法。 eg. Student stu1 = new UStudent(); //stu1自动转型为学生类对象
stu1.study(); //学生类对象调用的是大学生的学习方法
多态 一个学生能学习，但是引入了自动转型机制、大学生、中学生、小学生继承了学生类、方法重写了之后。父类对象调用一个study()方法，结果是不确定的。又如，我们大家都是人，但是由于我们每个人都是独特的。这就是多态最直接的体现。
eg.
public class Student(){
System.out.println("0000");
}
public class UStudent() extends Student{
System.out.println("1111");
}
public class SeniorStudent extends Student(){
System.out.println("2222");
}
//多态的体现：父类对象两次调用study，结果是完全不同的
Student stu1 = new UStudent();
stu1.study();
Student stu2 = new SeniorStudent();
stu2.study();
这里要着重注意的是，一个子类只可以继承一个父类，但是一个父类可以被多个子类去继承。
最后再总结一下：
1.一个class只能extends一个class（单根继承）
2.一个class可以implements多个interface
3. 一个interface可以extends多个interface
4.一个class可以在extends一个class的基础上再去implements多个interface