day_9java继承,object,final基本使用；类之间的继承、组合关系

继承

继承的概念

根据已有类派生出新类的技术。还可以有自己的独特属性。

为什么要使用继承？（优势）

1. 代码重用
2. 便于维护（高耦合，代码之间紧密联系）

注意：java类只支持单一继承，不允许多继承：即意味着一个父类可以有多个子类，但是子类只能有多个父类

语法：

编写父类

编写子类：在子类加上 extends 父类名称

使用

一：继承父类：子类继承父类的 “所有”成员，就像在自己类中使用

二：子类不能继承父类的：

1. 父类中private修饰的成员
2. 子类和父类不在同一程序包下，使用默认修饰符的成员
3. 构造器。

别称：

父类，超类，基类

子类，派生类

程序设计原则：里氏替换原则

子类是父类，子类完全替换父类不会出现问题

方法重写

子类中的方法名字，参数，返回值类型与父类中的一样

重写场合

1. 子类和父类中的方法的功能不同
2. 子类修改了父类中的功能

重写要注意：

1. 必须是子类
2. 必须是实例成员方法
3. 方法名必须已经有
4. 参数一样或父类擦除后和子类相同
5. 返回值类型和父类相同 或 子类可以是父类的子类型（引用）
6. 子类方法的访问修饰符 不能比父类更严格（低）
7. 异常处理，子类不能比父类异常范围更大

重载和重写的区别

区别点	重载	重写
位置	在同一个类中	在有继承关系的子类中
方法	方法名相同，参数列表不同，与返回值无关	方法名，参数，返回值类型与父亲一致
作用	方便记忆	修改父亲的功能
英文	overloading	overriding

super

父类的范围

可以调用父类的成员（成员变量，方法）

位置：

子类构造器的第一行代码处

作用

1. 区分子类和父类同名的成员
2. 调用父类构造器，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）增强可读性

什么情况下会派生新类

1. 子类 会增加属性
2. 子类 增加了方法

设计类的继承关系注意

1. 继承关系不要超过三层
2. 可以被子类继承的类
   • 写详细的文档说明
   • 尽量封装，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();
		
		
	}

}