继承
继承的概念
根据已有类派生出新类的技术。还可以有自己的独特属性。
为什么要使用继承？（优势）
- 代码重用
- 便于维护（高耦合，代码之间紧密联系）
注意：java类只支持单一继承，不允许多继承：即意味着一个父类可以有多个子类，但是子类只能有多个父类
语法：
编写父类
编写子类：在子类加上 extends 父类名称
使用
一：继承父类：子类继承父类的 “所有”成员，就像在自己类中使用
二：子类不能继承父类的：
1. 父类中private修饰的成员
2. 子类和父类不在同一程序包下，使用默认修饰符的成员
3. 构造器。
别称：
父类，超类，基类
子类，派生类
程序设计原则：里氏替换原则
子类是父类，子类完全替换父类不会出现问题
方法重写
子类中的方法名字，参数，返回值类型与父类中的一样
重写场合
- 子类和父类中的方法的功能不同
- 子类修改了父类中的功能
重写要注意：
1. .必须 子类
2. 必须是实例成员方法
3. 方法名必须以有
4. 参数一样 或父类擦除后和子类相同
5. 返回值类型和父类相同 或 子类可以是父类的子类型（引用）
6. 子类方法的访问修饰符 不能比父类更严格（低）
7. 异常处理，子类不能比父类异常范围更大
重载和重写的区别
| 区别点 | 重载 | 重写 |
|---|---|---|
| 位置 | 在同一个类中 | 在有继承关系的子类中 |
| 方法 | 方法名相同，参数列表不同，与返回值无关 | 方法名，参数，返回值类型与父亲一致 |
| 作用 | 方便记忆 | 修改父亲的功能 |
| 英文 | overloading | overriding |
super
父类的范围
可以调用父类的成员（成员变量，方法）
位置：
子类构造器的第一行代码处
作用
- 区分 子类和 父类同名的成员
- 调用父类构造器，super（）；
super使用注意：子类构造器中没有显示调用父类构造或本类构造，那么系统会自动分配一个super（）调用父类的==无参==构造器
父类中没有无参构造器，只有带参数的构造器，解决办法：
1. 在父类中定义一个无参构造器
2. 显示调用带参构造器，并且传参
this和super的区别和相同点
区别：
1、super()主要是对父类构造函数的调用，this()是对重载构造函数的调用
2、super()主要是在继承了父类的子类的构造函数中使用，是在不同类中的使用；this()主要是在同一类的不同构造函数中的使用
相同点：
1、super()和this()都必须在构造函数的第一行进行调用，否则就是错误的
继承的传递：
子类可以继承直接父类的成员，也可以继承间接父类的成员
object
finalize（）
垃圾回收之前调用
强制垃圾回收：System.gc();
//垃圾回收
package day16_1;
class Student{
@Override
protected void finalize() throws Throwable {
System.out.println("this----->"+this);
super.finalize();
}
}
public class TestStudent {
public static void main(String[] args) {
Student guojing = new Student();
System.out.println(guojing);
//断开
guojing = null;
//强制垃圾回收
System.gc();
System.out.println(guojing);
}
}
toString
对象的字符串描述信息
注意：在使用print（）或者println（）输出对象名字时，会自动调用toString
System.out.println(guojing);
System.out.println(guojing.toString());
//重写toString，调用tostring时，输出的是“我爱学习”
@Override
public String toString() {
// TODO Auto-generated method stub
return "我爱学习";
}
equals
//重写equals
@Override
public boolean equals(Object obj) {
// 所有的属性值都相同就是同一个对象
Student stu = (Student)obj;//父类类型强制转换为子类类型
return this.name.equals(stu.name) &&this.age ==stu.age;
}
public class TestStudent {
public static void main(String[] args) {
Student guojing = new Student("郭靖",22);
Student yangkang = new Student("郭靖",22);
System.out.println(guojing);
System.out.println(yangkang);
System.out.println(guojing.equals(yangkang));//object类的equals
String s = "abc";
System.out.println(s.equals("def"));//String类下也有equals类，并且是重写的object的
}
}
final
修饰符：
1. 类，不能被子类继承
- 为了类的安全性，不允许子类修改
- 类之间的方法有复杂的调用关系
- 此类是最终版本的类，不想再扩展了
2. 方法，不能被子类重写
- 不希望子类更改，所有子类使用的是父类同一版本的方法
3. 变量，值不能更改，这是也就是一个常量
- 对于基本数据类型值不能修改，
- 对于引用类型，不能换对象，对象里的值可以变
Final B b = new B();
b = new B（）；//出错，不能改对象
b.value = 45;//对象的值可以更改- 常量的命名规则：所有字母大写，单词之间用下划线连接
常量的好处
（1）安全性，不允许随意更改
（2）好维护，一个常量值更改了，所有应用的地方都改了
（3）增强可读性
什么情况下会派生新类
- 子类 会增加属性
- 子类 增加了方法
设计类的继承关系注意
- 继承关系不要超过三层
- 可以被子类继承的类
- 写详细的文档说明
- 尽量封装，private；对所有用户都开放，用public；只对子类开放，protected；对所有用户都开放，又不想被子类更改，用final
优点 ：
1.代码重用
2.便于维护
缺点：
1.高耦合
2.破坏封装
组合
整体和局部的关系
//发动机
class Engine{
public void start(){
System.out.println("启动");
}
public void stop(){
System.out.println("停止");
}
}
//轮子
class Wheel{
public void inflate(int r){
System.out.println("重气"+ r);
}
}
//车窗户
class Window{
public void roolUp(){
System.out.println("升");
}
public void roolDown(){
System.out.println("降");
}
}
//车门
class Door{
Window win = new Window();
public void open(){
System.out.println("车开门");
}
public void close(){
System.out.println("车关门");
}
}
//构造器
class Car{
Engine e = null;//
Wheel [] w =null;//
Door[] d = null;//new Door();
Car(){
e = new Engine();
w =new Wheel[4];
for(int i = 0;i <w.length;i++){
w[i] = new Wheel();
}
d = new Door[2];
for(int i = 0;i <d.length;i++){
d[i] = new Door();
}
}
}
public class TestCar {
public static void main(String[] args) {
Car car = new Car();
car.e.start();
car.e.stop();
for(int i = 0; i < car.w.length;i++){
car.w[i].inflate(100);
}
car.d[0].open();
car.d[1].close();
car.d[2].win.roolDown();
car.d[3].win.roolUp();
}
}