继承性
为什么要有继承
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。
类继承语法规则
class Subclass extends SuperClass{ }
作用
减少了代码冗余，提高了代码的复用性。
更有利于功能的扩展。
让类与类之间产生了关系，提供了多态的前提。
注意：不要仅为了获取其他类中某个功能而去继承
使用
子类继承了父类，就继承了父类的方法和属性。
在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
关于继承的规则：
子类不能直接访问父类中私有的(private)的成员变量和方法。但此时，依然继承了这个私有的变量、方法。
- Java只支持单继承和多层继承，不允许多重继承
一个子类只能有一个父类
一个父类可以派生出多个子类
class SubDemo extends Demo{ } //ok
class SubDemo extends Demo1,Demo2...//error
- 如果没有显示生命一个父类，则继承java.lang.object类。
且所有类直接或间接继承java.lang.object类
练习题
第一次打印定义base类，运行的是base2类，所以相当于在base2类要找base类重写的方法。
第二次打印定义base2类，运行的也是base2类，所以直接在base2里找方法，优先匹配形式一致的方法。
方法的重写
定义：(override/overwrite)
在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
要求：
子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
子类不能重写父类中声明为private权限的方法
子类方法抛出的异常不能大于父类被重写方法的异常
注意：
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为 static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。
super
在Java类中使用super来调用父类中的指定操作：
super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造器中调用父类的构造器
注意：
尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
super的追溯不仅限于直接父类
super和this的用法相像，this代表本类对象的引用，super代表父类内存空间的标识
调用父类的构造器：
子类中所有的构造器默认都会访问父类中空参数的构造器
当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行
如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错
this和super的区别
多态性
定义
多态性，是面向对象中最重要的概念，在Java中的体现：
对象的多态性：父类的引用指向子类的对象。可以直接应用在抽象类和接口上
Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）
“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
对象的多态
- 在Java中,子类的对象可以替代父类的对象使用
一个变量只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象
Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象
子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法
应用
方法的重载与重写
从编译和运行的角度看：
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
多态小结
多态作用：
提高了代码的通用性，常称作接口重用
前提：
需要存在继承或者实现关系
有方法的重写
成员方法：
编译时：要查看引用变量所声明的类中是否有所调用的方法。
运行时：调用实际new的对象所属的类中的重写方法。
成员变量：
不具备多态性，只看引用变量所声明的类。
子类继承父类
若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量
即：多态性，把父类和子类的属性和方法都加载在堆中，运行的是父类的属性（子类的属性加载进来但不能调用）和子类重写的方法（此方法父类中必须包含）。
instanceof
x instanceof A：检验变量x是否为类A的对象，返回值为boolean型。
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。
public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}
-------------------------------------------------------------------
public void method1(Person e) {
if (e instanceof Person)
// 处理Person类及其子类对象
if (e instanceof Student)
//处理Student类及其子类对象
if (e instanceof Graduate)
//处理Graduate类及其子类对象
}
对象类型转换(Casting )
1.基本数据类型的Casting：
自动类型转换：小的数据类型可以自动转换成大的数据类型
如long g=20; double d=12.0f
强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
如float f=(float)12.0; int a=(int)1200L
2.对Java对象的强制类型转换称为造型
从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过造型(强制类型转换)实现
无继承关系的引用类型间的转换是非法的
在造型前可以使用instanceof操作符测试一个对象的类型
单元测试
在方法名上面加入@Test注解，然后add导包，即可对其中一个方法进行测试。
要求：类为public、有public无参构造器、方法名public且无返回值无形参。
Object
Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
==
A.基本类型比较值:只要两个变量的值相等，即为true。
int a=5; if(a==6){…}
B.引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。
Person p1=new Person();
Person p2=new Person();
if (p1==p2){…}
此时比较的是p1、p2是否是同一地址。用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错。
equals()
A.所有类都继承了Object，也就获得了equals()方法。还可以重写。
B.只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。（地址值）
格式:obj1.equals(obj2)
C.特例：
当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
原因：
在这些类中重写了Object类的equals()方法。当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等
D.任何情况下
x.equals(null)，永远返回是“false”；
x.equals(和x不同类型的对象)永远返回是“false”。
==和equals的区别
== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也
是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
具体要看自定义类里有没有重写Object的equals方法来判断。
通常情况下，重写equals方法，会比较类中的相应属性是否都相等。
int it = 65;
float fl = 65.0f;
System.out.println(“65和65.0f是否相等？” + (it == fl)); //true
char ch1 = 'A'; char ch2 = 12;
System.out.println("65和'A'是否相等？" + (it == ch1));//true
System.out.println(“12和ch2是否相等？" + (12 == ch2));//true
toString()
toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
在进行String与其它类型数据的连接操作时，自动调用toString()方法
Date now=new Date();
System.out.println(“now=”+now); 相当于System.out.println(“now=”+now.toString());
- 可以根据需要在用户自定义类型中重写toString()方法
如String 类重写了toString()方法，返回字符串的值。
s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString());
基本类型数据转换为String类型时，调用了对应包装类的toString()方法
int a=10; System.out.println(“a=”+a);
面试题：
char[] arr = new char[] { 'a', 'b', 'c' };
System.out.println(arr); //abc
int[] arr1 = new int[] { 1, 2, 3 };
System.out.println(arr1); //[I@1c655221
double[] arr2 = new double[] { 1.1, 2.2, 3.3 };
System.out.println(arr2); //[D@58d25a40
包装类的使用
装箱拆箱
JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。
A.基本数据类型包装成包装类的实例—装箱
通过包装类的构造器实现：
int i = 500; Integer t = new Integer(i);
还可以通过字符串参数构造包装类对象：
Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException
B.获得包装类对象中包装的基本类型变量—拆箱
调用包装类的.xxxValue()方法：
boolean b = flag.booleanValue();
字符串、基本数据类型转换
A.字符串转换成基本数据类型
通过包装类的构造器实现：
int i = new Integer(“12”);
通过包装类的parseXxx(String s)静态方法：
Float f = Float.parseFloat(“12.1”);
B.基本数据类型转换成字符串
调用字符串重载的valueOf()方法：
String fstr = String.valueOf(2.34f);
更直接的方式：
String intStr = 5 + “”
面试题
Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1); // 1.0
执行三元判断时，都运行了，所以int型，类型提升
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); // false （两个地址值不一样）
Integer m = 1;
Integer n = 1;
System.out.println(m == n);// true
（为快速加载，该类提前定义数组[-128，127]，所以没有经过new，两个1均从数组里取值）
Integer x = 128;
Integer y = 128;
System.out.println(x == y);// false （超过127，需要重新new）
