本文共 4144 字，大约阅读时间需要 13 分钟。
子类和父类有相同的成员方法（方法名，参数，返回值一样）。
子类可以继承父类的方法，但想满足更多需求，不想用父类的方法。
覆写出现必须存在继承关系；方法名，参数列表，返回值必须相同；不能有更低的访问权限；不能有更宽泛的异常。
继承最基本的作用：代码重用； 继承最重要的功能：代码覆写；package day10_test;public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Cat cat = new Cat(); cat.move(); Animal a1 = new Cat(); a1.move(); Animal a2 = new Dog(); a2.move(); }}class Animal{ public void move(){ System.out.println("动物在移动"); }}class Cat extends Animal{ @Override public void move(){ System.out.println("猫在舞"); }}class Dog extends Animal{ public void move(){ System.out.println("狗在跑"); }} final是修饰符，表示最终的，不能更改；不能被继承；修饰的成员方法不能被覆写；修饰的变量没有默认值，必须显式赋值，生命周期中不能更改。
常量一般写为public static final，常量命名建议全部大写final class A{ // 报错 编译时异常 final类不能被继承 }class B extends A{ } class A{ public final void m1(){ }}class B extends A{ public void m1(){ }// 报错 编译时异常 final方法不能被覆写} final int a;// 报错 需要显示赋值
package day10_test;public class Test_03 { public static void main(String[] args) { // TODO Auto-generated method stub final User user = new User(22); user.age = 24; System.out.println(user.age);// user = null;会报错，此处改null，就是改变user变量的值 }}class User{ int age; public User(int age){ super(); this.age = age; }} final修饰的引用数据类型，以上代码为例，改变的是User，不是age，所以不会报错，改变User和改变User引用的堆内存中的数据不是一个概念。
软件设计六大原则：
单一职责原则：一个方法只负责一件事； 里氏替换原则：能够使用父类的地方就能够使用子类(多态是里氏替换原则的一种体现)； 依赖倒置原则：和父类打交道，不需要管子类，依赖抽象不依赖具体实现； 接口隔离原则：类和类之间应该建立在最小接口上； 迪米特原则：一个对象应该对其他对象尽可能少地了解； 开闭原则：通过扩展实体解决需求变化，不是通过修改已经有的代码完成变化；
同一消息（函数调用的时候），不同类的对象会有不同的行为方式。
package day10_test;public class Test_04 { public static void main(String[] args) { // TODO Auto-generated method stub A a = new A(); m1(a); B b = new B(); m1(b); } public static void m1(X x){ x.m1(); }}class X{ public void m1(){ }}class A extends X{ public void m1(){ System.out.println("A"); }}class B extends X{ public void m1(){ System.out.println("B"); }} 多态就是父类引用指向子类对象。
父类引用：使用父类类型创建的引用类型变量； 指向：通过这个引用类型变量，可以找到那个对象； 子类对象：创建 的子类对象； 父类 变量 = new 子类（）；编译时多态是静态的，主要指方法重载，通过不同参数列表区分不同的方法，编译后会形成不同的两个方法，运行时调用该方法就算多态了，因为调用的是两个方法。
运行时多态是动态的，主要是动态绑定实现，子类实现父类的方法来完成，这就是多态性。
多态丢失了子类特有的属性。
public static void m1(Sup s){ m1(new Sub());} public Sup m1(){ return new Sub();} 使用多态进行属性调用，父类没有，编译时报错；父类有，子类没有，执行父类；父类有，子类也有，除了成员方法执行子类，其他执行父类。
this发生多态；this可以调用当前类所有属性，所以一定不是父类类型，因为多态会丢失子类特有属性，所以this一定是当前类类型（this所在类就是当前类）。
通过子类对象调用父类方法的时候，父类的这个方法上下文环境就是多态对象。子类到父类是自动转换，父类到子类是强制转换，又叫向下转型，必须先向上转型才能向下转型。
instanceof判断某个对象是否由某个类实例化而来。 直接类型转换容易导致错误。package day10_test;public class Test_05 { public static void main(String[] args) { // TODO Auto-generated method stub Animal1 an = new Cat1(); an.m1(); Cat1 ca = (Cat1) an; // ca.m1(); an.m1(); isAB(an); isAB(ca); Dog1 do1 = new Dog1(); isAB(do1); } public static void isAB(Object o){ if(o instanceof Animal1){ System.out.println("Animall"); }else if(o instanceof Cat1){ System.out.println("Cat"); }else{ System.out.println("No"); } }}class Animal1{ public void m1(){ // System.out.println("a"); };}class Cat1 extends Animal1{ public void m1(){ System.out.println("cat"); }}class Dog1{ public void m2(){ System.out.println("Dog"); }} Object是java提供的根类，所有类都要直接或者间接继承Object，意味Object中的所有方法是所有类都有的。
比较两个对象是否相等。
引用类型比较地址，可不同对象地址一定不同，没有太大比较价值。 两个对象进行比较的时候，肯定是拿有意义的属性进行比较，不会使用==，而是使用equals。 默认的Object中的equals方法比较内存地址，可以根据需求进行重写。 任何比较最后都是转化为基础类型进行比较。 String中的equals已经覆写好，可以直接用。当没有更多引用指向该对象的时候，此时该对象被视为垃圾数据。
Object的finalize方法是当前对象被回收之间，自动调用该方法。finalize方法所有对象共有；
finalize方法不需要程序员调用，由系统调用； 就算对finalize方法进行调用，也没有垃圾回收的功能； finalize并不会进行垃圾回收，只是在垃圾回收前自动执行一次； 重写后可以在对象销毁前做一些关闭资源等销毁操作；
使用System.gc()可以建议垃圾回收自动回收，却不一定会回收。
哈希值不保证唯一。
同一对象生成多次，一定是相同的值，不同对象生成多次，可能产生相同的值，这就是哈希冲突。 hashcode设计目的是为了给每个对象生成唯一的标识符。返回该对象的字符串形式，Object中的toString方法，默认返回内存地址，当我们输出一个引用类型对象的时候，会自动调用该对象的toString方法。
转载地址：http://shhu.baihongyu.com/