现实生活中有很多现实的例子都是封装的，例如： 手机，电视机，笔记本电脑，照相机，这些都是外部有一个坚硬的壳儿。 封装起来，保护内部的部件。保证内部的部件是安全的。另外封装了之后， 对于我们使用者来说，我们是看不见内部的复杂结构的，我们也不需要关心 内部有多么复杂，我们只需要操作外部壳儿上的几个按钮就可以完成操作。
封装的作用有两个： a)、实现了专业的分工。将能实现某一特定功能的代码封装成一个独立的实体后，各程序员可以在需要的时候调 用，从而实现了专业的分工,即工作中的分模块、分功能开发。
b)、隐藏信息，实现细节。通过控制访问权限可以将可以将不想让客户端程序员看到的信息隐藏起来，如某客户的 银行的密码需要保密，只能对该客户开发权限一个类体当中的数据，假设封装之后，对于代码的调用人员来说，不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。 另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，来保证数据的安全性。
通过访问权限 public protected default private 来封装类、方法及属性，达到隐藏细节的目的，最终达到“该露的 露，不该露的别瞎露”目的。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VXfQ4dSF-1593525234387)(C:\Users\dell\AppData\Roaming\Typora\typora-user-images\1593521986125.png)]
继承：在现实世界当中也是存在的，例如：父亲很有钱，儿子不用努力也很有钱。 继承的作用： 基本作用：子类继承父类，代码可以得到复用。（这个不是重要的作用，是基本作用。） 主要(重要)作用：实现代码的复用，延续+扩展父类信息。 继承后子类自动拥有了父类的属性和方法，但特别注意的是，父类的私有 属性和构造方法并不能被继承。另外子类可以写自己特有的属性和方法，目的是实现功能的扩展，子类也可以复写 父类的方法即方法的重写
① B类继承A类，则称A类为超类(superclass)、父类、基类， B类则称为子类(subclass)、派生类、扩展类。 class A{} class B extends A{} 我们平时聊天说的比较多的是：父类和子类。 superclass 父类 subclass 子类
② java 中的继承只支持单继承，不支持多继承，C++中支持多继承， 这也是 java 体现简单性的一点，换句话说，java 中不允许这样写代码：class B extends A,C{ } 这是错误的。
③ 虽然 java 中不支持多继承，但有的时候会产生间接继承的效果， 例如：class C extends B，class B extends A，也就是说，C 直接继承 B，其实 C 还间接继承 A。
④ java 中规定，子类继承父类，除构造方法不能继承之外，剩下都可以继承。但是私有的属性无法在子类中直接访问。(父类中private修饰的不能在子类中直接访问。可以通过间接的手段来访问。)
⑤ java 中的类没有显示的继承任何类，则默认继承 Object类，Object类是 java 语言提供的根类（老祖宗类），也就是说，一个对象与生俱来就有 Object类型中所有的特征。
⑥ 继承也存在一些缺点，例如：CreditAccount 类继承 Account 类会导致它们之间的耦合度非常高，Account 类发生改变之后会马上影响到 CreditAccount 类
凡是采用“is a”能描述的，都可以继承。 例如： Cat is a Animal：猫是一个动物 Dog is a Animal：狗是一个动物 CreditAccount is a Account：信用卡账户是一个银行账户 …
假设以后的开发中有一个A类，有一个B类，A类和B类确实也有重复的代码， 那么他们两个之间就可以继承吗？不一定，还是要看一看它们之间是否能够 使用is a来描述。 class Customer{ String name; // 名字 // setter and getter } class Product{ String name; // 名字 // setter and getter } class Product extends Customer{ } 以上的继承就属于很失败的。因为：Product is a Customer，是有违伦理的。父类中的方法无法满足子类的业务需求，子类有必要对继承过来的方法进行覆盖。
第一：有继承关系的两个类 第二：具有相同方法名、返回值类型、形式参数列表 第三：访问权限不能更低。 第四：抛出异常不能更多。
注意：
属性不会覆盖
私有方法无法覆盖。
方法覆盖只是针对于“实例方法”，“静态方法覆盖”没有意义。（这是因为方法覆盖通常和多态联合起来）
总结三句话： 私有不能覆盖。
静态不谈覆盖。
final 修饰方法不能覆盖。
toString()方法存在的作用就是：将java对象转换成字符串形式。 大多数的java类toString()方法都是需要覆盖的。因为Object类中提供的toString() 方法输出的是一个java对象的内存地址。
方法重载发生在同一个类当中。
方法覆盖是发生在具有继承关系的父子类之间。
方法重载是一个类中，方法名相同，参数列表不同。
方法覆盖是具有继承关系的父子类，并且重写之后的方法必须和之前的方法一致： 方法名一致、参数列表一致、返回值类型一致。
静态绑定**(静态联编)**: 在编译期完成，可以提高代码执行速度。静态绑定的方法包括：
静态方法
构造器
private方法
用关键字super 调用的方法
动态绑定**(动态联编)**：指在“执行期间（而非编译期间）” 判断所引用对象的实际类型，根据其实际的类型调用其相 应的方法。 这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。
多种形态，多种状态，编译和运行有两个不同的状态。 编译期叫做静态绑定。 运行期叫做动态绑定。 Animal a = new Cat(); // 编译的时候编译器发现a的类型是Animal，所以编译器会去Animal类中找move()方法 // 找到了，绑定，编译通过。但是运行的时候和底层堆内存当中的实际对象有关 // 真正执行的时候会自动调用“堆内存中真实对象”的相关方法。 a.move();
多态的典型代码：父类型的引用指向子类型的对象。
要发生多态有三个必要条件：要有继承，要有重写，父类引用指向子类对象
public class Animal { public void eat(){ System.out.println("eat....."); } public void shout(){ System.out.println("shout....."); } } public class Dog extends Animal { //重写 public void shout(){ System.out.println("主人我是旺财....."); } } public class Pig extends Animal{ //重写 public void shout(){ System.out.println("我是世界最聪明的动物....."); } //新增 public void gongDi(){ System.out.println("拱地........."); } }super能出现在实例方法和构造方法中。
super的语法是：“super.”、“super()”
super不能使用在静态方法中。
super. 大部分情况下是可以省略的。
super.什么时候不能省略呢？ 父类和子类中有同名属性，或者说有同样的方法， 想在子类中访问父类的，super. 不能省略。
super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中 的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。
super的使用： super.属性名 【访问父类的属性】 super.方法名(实参) 【访问父类的方法】 super(实参) 【调用父类的构造方法】
public class Test { public static void main(String[] args) { new ChildClass().f(); } } class Father { public int value; public Father(){ } public Father(int a){ value =a; System.out.println("Father(int)"); } public void f(){ value = 100; System.out.println("Father.value="+value); } } class Child extends Father { public int value; public Child(){ super(12); } public void f() { super.f(); value = 200; System.out.println("Child.value="+value); System.out.println(value); System.out.println(super.value); } }final修饰的类无法继承。 final修饰的方法无法覆盖。 final修饰的变量只能赋一次值。 final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用指向的对象内部的数据是可以修改的。 final修饰的实例变量必须手动初始化，不能采用系统默认值。 final修饰的实例变量一般和static联合使用，称为常量。 public static final double PI = 3.1415926;
常量：常量名必须全部用大写字母，字母之间用"_"分隔
第一：抽象类怎么定义？在class前添加abstract关键字就行了。 第二：抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。 第三：final和abstract不能联合使用，这两个关键字是对立的。 第四：抽象类的子类可以是抽象类。也可以是非抽象类。 第五：抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。 第六：抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。 第七：抽象方法怎么定义？ public abstract void doSome(); 第八：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。
//有抽象方法的类也必须被声明为abstract public class Test1 { public static void main(String[] args) { Teacher teacher=new Teacher("教师"); teacher.work(); Driver driver=new Driver("驾驶员"); driver.work(); } } abstract class People{ //抽象方法 public abstract void work(); } class Teacher extends People{ private String work; public Teacher(String work) { this.work=work; } @Override public void work() { System.out.println("我的职业是"+this.work); } } class Driver extends People{ private String work; public Driver(String work) { this.work=work; } @Override public void work() { System.out.println("我的职业是"+this.work); } 1、接口是一种“引用数据类型”。 2、接口是完全抽象的。 3、接口怎么定义：[修饰符列表] interface 接口名{} 4、接口支持多继承。 5、接口中只有常量+抽象方法。 6、接口中所有的元素都是public修饰的 7、接口中抽象方法的public abstract可以省略。 8、接口中常量的public static final可以省略。 9、接口中方法不能有方法体。 10、一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现。 11、一个类可以实现多个接口。 12、extends和implements可以共存，extends在前，implements在后。 13、使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）。
注意：接口在开发中的作用，类似于多态在开发中的作用。
多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力。 /* public class Master{ public void feed(Dog d){} public void feed(Cat c){} //假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了） //这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。） } */ public class Master{ public void feed(Animal a){ // 面向Animal父类编程，父类是比子类更抽象的。 //所以我们叫做面向抽象编程，不要面向具体编程。 //这样程序的扩展力就强。 } } 面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）
抽象类是半抽象的。 接口是完全抽象的。
抽象类中有构造方法。 接口中没有构造方法。
接口和接口之间支持多继承。 类和类之间只能单继承。
一个类可以同时实现多个接口。 一个抽象类只能继承一个类（单继承）。
(Dog d){} public void feed(Cat c){} //假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了） //这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。） } */
public class Master{ public void feed(Animal a){ // 面向Animal父类编程，父类是比子类更抽象的。 //所以我们叫做面向抽象编程，不要面向具体编程。 //这样程序的扩展力就强。 } } 面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。） ### 8.3抽象类和接口的区别 抽象类是半抽象的。 接口是完全抽象的。 抽象类中有构造方法。 接口中没有构造方法。 接口和接口之间支持多继承。 类和类之间只能单继承。 一个类可以同时实现多个接口。 一个抽象类只能继承一个类（单继承）。 接口中只允许出现常量和抽象方法。