面向对象的三大特征
封装（Encapsulation）
继承（Inheritance）
多态（Polymorphism）
我们程序设计追求“高内聚，低耦合”
高内聚：类的内部数据操作细节自己完成，不允许外部干涉低耦合：仅对外暴露少量的方法用于使用。隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露岀来。这就是封装性的设计思想。
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setName()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private)。此时，针对于属性就体现了封装性。
体现一：
将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
private double radius; public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; }体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。
封装性的体现，需要权限修饰符来配合
通过对不同的方法属性设置不同的权限修饰符来达到对类进行封装的目的。
权限从小到大顺序为：private < 缺省 < protected < public具体的修饰范围：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oH47Gyu9-1603365852990)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201022180643782.png)]
权限修饰符可用来修饰的结构说明：
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类修饰类，只能使用：缺省、public是Java中所有类的父类，类似于二叉树中的根节点，定义了一些通用的方法。
如果我们没显式的声明一个类的父类的话，则此类继承于java.lang.Object类所的java类（除java.lang.Object类之外都直接或间接的继承于java.lang.Object类意味着，所的java类具有java.lang.Object类声明的功能。java.lang.Object类中定义的一些方法
方法名类型描述public Object()构造方法构造器public boolean equals( Object obj)普通方法对象比较public int hashCode()普通方法获取Hash码public String toString()普通方法对象打印时调用属性：无
方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()
wait() 、 notify()、notifyAll()
Object类只声明了一个空参的构造器数组也作为 Object类的子类出现，可以调用 Object类中声明的方法使用说明：
Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。通常情况下，我们自定义的类如果使用equals()的话，也通常是用来比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写.重写的原则：比较两个对象的实体内容是否相同.手动重写举例：
class User{ String name; int age; //重写其equals()方法 public boolean equals(Object obj){ if(obj == this){//判断形参和比较对象的引用地址是否相同，相同直接返回true return true; } if(obj instanceof User){ User u = (User)obj; return this.age == u.age && this.name.equals(u.name); } return false; } }自动生成的代码：
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true;回顾 == 运算符的使用：
== ：运算符
可以使用在基本数据类型变量和引用数据类型变量中
如果比较的是基本数据类型变量：
比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型变量：
比较两个对象的地址值是否相同,即两个引用是否指向同一个对象实体
使用说明
== 符号使用时，必须保证符号左右两边的变量类型一致。（否则编译都过不了）基本数据类型用==，引用数据类型用equalstoString()的使用:
当我们输出一个对象的引用时，实际上就是调用当前对象的toString()方法
Object类中toString()的定义：
public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息。
自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
重写toString()
//自动实现 @Override public String toString() { return "Customer [name=" + name + ", age=" + age + "]"; }子类继承父类以后，就获取了父类中声明的属性或方法。 创建子类的对象，在堆空间中，就会加载所父类中声明的属性。
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，…直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中父类中的结构，子类对象才可以考虑进行调用。
虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。
就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
可以理解为一个事物的多种形态。
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。
多态性是对象多种表现形式的体现。
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
编译时和运行时类型不一致，产生了多态
代码举例：
Person p = new Man(); Object obj = new Date();① 类的继承关系 ② 方法的重写 ③父类的引用指向子类的对象
Student m = new Student(); m.school = “pku”; //合法,Student类有school成员变量 Person e = new Student(); e.school = “pku”; //非法,Person类没有school成员变量 属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。
向上转型：多态
有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。
使用强制类型转换符：()
Person p = new Man(); Man m1=（Man）p2；//向下转型① 使用强转时，可能出现ClassCastException的异常。
② 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
③ A instanceof B 只有对象A是B的子类实例化对象或者在下层的子类，才能向下转型
① a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
② 如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。
③ 要求a所属的类与类A必须是子类和父类的关系，否则编译错误。
p instanceif Man//左边是变量名，右边是类的类型1.谈谈你对多态性的理解？
就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
实现代码的通用性。举例： Object类中定义的public boolean equals(Object obj){ }JDBC:使用java程序操作(获取数据库连接、CRUD)数据库(MySQL、Oracle、DB2、SQL Server）抽象类、接口的使用肯定体现了多态性。（抽象类、接口不能实例化）2.多态是编译时行为还是运行时行为？
运行时行为
class Base { int count = 10; public void display() { System.out.println(this.count); } } class Sub extends Base { int count = 20; public void display() { System.out.println(this.count); } } public class FieldMethodTest { public static void main(String[] args) { Sub s = new Sub(); System.out.println(s.count);//20 s.display();//20 Base b = s;//多态性 //==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同 System.out.println(b == s);//true System.out.println(b.count);//10 b.display();//20 } } 若子类重写了父类方法，就意味着子类里面定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边 rintln(this.count); } }public class FieldMethodTest { public static void main(String[] args) { Sub s = new Sub(); System.out.println(s.count);//20 s.display();//20
Base b = s;//多态性 //==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同 System.out.println(b == s);//true System.out.println(b.count);//10 b.display();//20 }}
1. 若子类重写了父类方法，就意味着子类里面定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边 2. 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边