22.面向对象特征之二： 继 承
01.多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么子类无需再定义这些属性和行为，只要继承父类即可。
02.定义方法：
//定义父类
public class Person {
public String name;
public int age;
public String getInfo() {...}
}
//使用extends关键字定义继承的子类，意即对父类的"扩展".
public class Student extends Person{
public String school;
}
//Student类继承了父类Person的所有属性和方法，并增加了一个属性school.
//Person中的属性和方法,Student都可以利用.
//如果子类和父类不在同一个包下，子类只能使用父类中public和protected修饰的成员
03.继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
不要仅为了获取其他类中某个功能而去继承,继承的类之间应该有逻辑性
子类不能直接访问父类中私有的(private)的成员变量和方法,应通过setter、getter方法访问
04.一个子类只能有一个父类，一个父类可以派生出多个子类，Java支持多层继承，但不支持一个子类多个父类这样的 多重继承
05.方法的重写(override)
(1).在子类中可以根据需要对从父类中继承来的方法进行改造，子类的方法将覆盖父类的方法,称重写。
(2).方法重写时的注意：
a.重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。
b.重写方法不能使用比被重写方法更严格的访问权限。
c.重写和被重写的方法须同时为static的，或同时为非static的
d.子类方法抛出的异常不能大于父类被重写方法的异常
(3).重写示例代码：
public class Person {
public String name;
public int age;
public String getInfo() {
return "Name: "+ name + "\n" +"age: "+ age;
}
}
public class Student extends Person {
public String school;
public String getInfo() { //重写方法
return "Name: "+ name + "\nage: "+ age
+ "\nschool: "+ school;
}
}(4).在eclipse中可以使用快捷键 Alt+/ 选择override进行快速重写。
23.关键字super
01.super可用于访问父类中定义的属性，方法，以及父类的构造函数.
02. a.尤其当子父类出现同名成员时，可以用super进行区分
b.super的追溯不仅限于直接父类，还可以调用子类之上的所有父类
c.super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识
03.使用方法：可以使用 super.+父类成员 进行调用。
04.注意：
a.子类中所有的构造器默认都会访问父类中空参数的构造器
b.当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语 句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行
c.如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错
代码示例：
//父类
1 public class Person {
2
3 private String name;
4 private int age;
5 private Date birthDate;
6
7 public Person(String name, int age, Date d) {
8 this.name = name;
9 this.age = age;
10 this.birthDate = d;
11 }
12 public Person(String name, int age) {
13 this(name, age, null);
14 }
15 public Person(String name, Date d) {
16 this(name, 30, d);
17 }
18 public Person(String name) {
19 this(name, 30);
20 }
21
22 }//调用父类
1 public class Student extends Person {
2 private String school;
3
4 public Student(String name, int age, String s) {
5 super(name, age);
6 school = s;
7 }
8 public Student(String name, String s) {
9 super(name);
10 school = s;
11 }
12 public Student(String s) { // 编译出错: no super(),系统将调用父类
无参数的构造方法。
13 school = s;
14 }
15 }
24.this和super的区别
25.面向对象的特征之三：多态性
（1）Java中多态性的两种体现：
01.方法的重载(overload)和重写(overwrite).
a.重载：本类中允许同名方法存在，体现相同的方法实现不同的逻辑
b.重写：子类对父类方法的覆盖，子类可以使用和父类相同的方法名，覆盖掉父类的逻辑
02.对象的多态性 --子类的对象可以替代父类的对象使用,可以直接应用在抽象类和接口上.
03.Java引用变量有两个类型：
编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。若编译时类型和运行时类型不一致，就出现多态（Polymorphism）
（2）对象的多态性：
01.一个变量只能有一种确定的数据类型，但一个引用类型变量可能指向(引用)多种不同类型的对象
示例：
Person p = new Person();
Person e = new Student(); // Person类型的变量e，指向Student类型的对象
02.子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting).
即子类的对象可以给父类类型的变量作为引用
03.一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，
那么该变量就不能再访问子类中添加的属性和方法
示例：
Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量
//属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。 04.虚拟方法调用
//正常的方法调用
Person p = new Person();
p.getInfo();
Student s = new Student();
s.getInfo();
//虚拟方法调用(多态情况下)
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法
//编译时类型和运行时类型编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。
//Java的方法是运行在栈内存中的，在运行方法时会动态进栈和出栈--动态绑定. (3)多态小结：
前提：
需要存在继承或者实现关系
要有覆盖操作
成员方法：
编译时：要查看引用变量所属的类中是否有所调用的方法.
运行时：调用实际对象所属的类中的重写方法.
成员方法的多态性，也就是多态绑定，必须在有方法的重写前提下才能进行.
成员变量：
不具备多态性，只看引用变量所属的类.
26.instanceof操作符
01.x instanceof A：检验x是否为类A的对象，返回值为boolean型.
02.要求x所属的类与类A必须是子类和父类的关系，否则编译错误.
03.如果x属于类A的子类B，x instanceof A值也为true.
27.Object类
01.Object类是所有Java类的根父类（基类）.
在多层继承中处于最高层的父类一定是Object类
02.如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类
public class Person {
...
}
//等价于：
public class Person extends Object {
...
}
03.可以用于接收作为参数的类.
//示例：
method(Object obj){…}//可以接收任何类作为其参数
Person o=new Person();
method(o);
04.Object类中的方法
Object是所有类的父类，子类可以调用父类的方法，所以Object中的方法在其他所有类中都可以使用 对象.方法()
方法列表：
| num | 方法 | 类型 | 描述 |
| a | public Object() | 构造 | 构造方法 |
| b | public boolean equals(Object obj) | 普通 | 对象比较 |
| c | public int hashCode() | 普通 | 取得Hash码 |
| d | public String toString() | 普通 | 对象打印时调用 |
28.对象类型转换(Casting)
01.对Java对象的强制类型转换称为造型
a.从子类到父类的类型转换可以自动进行
b.从父类到子类的类型转换必须通过造型(强制类型转换)实现
c.无继承关系的引用类型间的转换是非法的
d.String类是Object类的子类，所以也满足上面的法则
对象类型转换代码示例：
public class Test{
public void method(Person e){ //设Person类中没有getschool() 方法
// System.out.pritnln(e.getschool()); //非法,编译时错误，因为e在形参传入时是Person类的对象,没有.getschool()方法，应该进行判断和转换
if(e instanceof Student){
Student me = (Student)e; //将e强制转换为Student类型
System.out.pritnln(me.getschool());
}
}
public static void main(Stirng args[]){
Test t = new Test();
Student m = new Student();
t.method(m);
}
}
29.==操作符与equals方法
01. ==操作符
a.基本类型比较值:只要两个变量的值相等，即为true.
b.引用类型比较引用(是否指向同一个对象):只有指向同一个对象时(在内存中的地址)，==才返回true.
c.用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错.
02.equals()方法
a.所有类都继承了Object，也就获得了equals()方法。还可以重写.
b.只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象(地址)
c.调用格式：obj1.equals(obj2)
d.特例：当用equals()方法进行比较时，对类File、String、Date及包装类来说，因为在这些类中重写了Object类的equals()方法，所以比较的是类型及内容，而不是引用的是否是同一个对象.
30.String对象的创建
31.toString()方法
01.toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
02.打印对象时，默认输出对象的内存地址，即输出 对象.toString()
32.包装类(Wrapper)
01.针对八种基本定义相应的引用类型—包装类（封装类）
02.基本数据类的包装类主要用于基本数据类型与字符串之间的转换
03.基本数据类型的实例化转为对应的包装类后，就有了类的特点，就可以调用类中的方法。
基础数据类型对应包装类列表
| 基本数据类型 | 包装类 |
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
04.基本数据类型包装成包装类 ---装箱
//通过包装类的构造器实现：
int i = 500; Integer t = new Integer(i);
//还可以通过字符串参数构造包装类对象：
Float f = new Float(“4.56”); 05.获得包装类对象中包装的基本类型变量 ---拆箱
//调用包装类的.xxxValue()方法：
boolean b = bObj.booleanValue();06.JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。
07.使用包装类进行字符串与基本数据类型之间的转换.
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 + “”;下节传送门：《JAVA SE学习笔记(六)：面向对象编程-c》
