6、继承

目录

• 继承
  • 方法的重写
    • 为什么要重写父类的方法呢？
    • 为什么不重新写一个新的方法呢？
    • 重写的特点：
    • 代码：
  • final关键字
    • 修饰变量
    • 修饰方法
    • 修饰类
  • Object
    • toString方法
    • equals方法
  • 抽象类
    • 定义：
    • 概念：
    • 声明抽象方法会造成以下两个结果：
  • 抽象类总结规定
  • 代码练习

继承

继承：类是对对象进行抽象，继承为了对一些类进行抽象，从而更好的建模，提高代码的复用性。

子类继承父类的成员变量和成员方法，但不继承构造方法。java是单继承的，一个类只能有一个父类。

如果一个类没有继承其他的类，那么他会默认继承Object类，Object是所有类的根类。

。。。。。。。。被final修饰的类不能被继承。。。。。。。。

class Pet{}
class Dog extends Pet{}

不能被继承的：

private 修饰的
子类和父类不在同一个包，使用默认修饰符的
构造方法

方法的重写

为什么要重写父类的方法呢？

当父类的一个方法的逻辑不满足子类需要的逻辑时，我们可以自己写上我们自己想要的逻辑，我们就可以重写父类的该方法来达到我们想要的结果。还可以通过super.方法名来完成父类未完成的事情。

为什么不重新写一个新的方法呢？

当子类需要多次用到一个方法的逻辑的时候，我们就可以通过父类的引用去调用该方法，这样可以提高代码的复用性，如果子类没有重写父类的方法，而是自己定义的，则父类的引用就调不到子类的该方法，所以我们要重写父类的方法而不是自己写一个。

重写的特点：

方法的名称，返回值类型，参数列表必须保持一致，访问修饰符不能低于父类的访问权限。

代码：

//父类
class Pet{
	public void eat(){
		sout("吃东西");
	}
}
//子类
class Dog extends Pet{
	public void eat(){
		//自己定义的逻辑
		sout("狗吃骨头");
	}
}
//子类
class Cat extends Pet{
	public void eat(){
		super.eat();
		sout("猫");
	}
}

final关键字

修饰变量

一旦赋值，就不可改变。修饰成员变量的时候，必须要初始化值，命名规则都是大写，多个单词用	_	隔开，修饰的成员变量变成常量。
修饰引用数据类型：引用不能被赋值，但属性可以被赋值
 

修饰方法

修饰方法时，该方法不能够被重写。

修饰类

修饰类时，该类不能被继承

Object

object类是所有类的父类，一个类如果没有声明父类是谁，默认是object类；

toString方法

默认返回 类名+包名+@+哈希码

可以重写方法来显示我们想要成员变量的信息

equals方法

默认比较的是 ==

可以按照我们自己定义的规则来进行比较，所有我们要重写equals方法s

==：
比较两基本类型变量的值是否相等
比较两个引用类型的值即内存地址是否相等，即是否指向同一对象。
equals() ：
两对象的内容是否一致
示例
object1.equals(object2)     如：p1.equals(p2)
比较所指对象的内容是否一样
是比较两个对象，而非两个基本数据类型的变量
object1 == object2        如：p1==p2
比较p1和p2的值即内存地址是否相等，即是否是指向同一对象。
 
自定义类须重写equals()，否则其对象比较结果总是false。

抽象类

定义：

用abstract修饰的类是抽象类。用来修饰方法就变成抽象方法。有抽象方法的类一定是抽象类，但有抽象类不一定有抽象方法。

概念：

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

抽象类也可以有构造方法，自己却不用来创建实例，而给子类去调用，这样父类的成员变量和成员方法就给到子类了。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

//一般用于父类，不能创建实例
public abstract class Pet{
	private String name;
	private int age;
	public abstract void eat();//抽象方法不能有方法体
	public void brak(){
	
	}
}
//在抽象类中也可以有成员变量和方法
//子类去继承，必须重写父类的抽象方法
public class Dog extends Pet{
	public void eat(){
	
	}
}

声明抽象方法会造成以下两个结果：

• 如果一个类包含抽象方法，那么该类必须是抽象类。
• 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象

普通类继承抽象类，就必须重写抽象父类的所有的抽象方法，如果是抽象类继承另外一个抽象类，就可以重写部分的抽象方法，可以不重写。

抽象类总结规定

• \1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
• \2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
• \3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
• \4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
• \5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

代码练习

package pre;
 
public class Animal {
	private int age;
	public Animal() {}
	public Animal(int age) {
		this.age = age;
	}
	public void introduce() {
		System.out.println("今年"+age+"岁了");
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
 

package pre;
 
public class Bird extends Animal{
	private String color;
	public Bird () {}
	public Bird(int age,String color) {
		super(age);
		this.color = color;
	}
	public void fly() {
		System.out.println("我展翅高飞");
	}
	public void introduce() {
		System.out.println("我是一只"+color+"的鸟");
		super.introduce();
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	
}
 

package pre;
 
public class Fish extends Animal{
	private double weight;
	public Fish() {}
	public Fish(int age,double weight) {
		super(age);
		this.weight = weight;
	}
	public void swimming() {
		System.out.println("我在水里悠闲吐泡");
	}
	public void introduce() {
		System.out.println("我是一只"+weight+"斤重的鱼");
		super.introduce();
	}
	public double getWeight() {
		return weight;
	}
	public void setWeight(double weight) {
		this.weight = weight;
	}
	
	
}
 

package pre;
 
public class Test {
	public static void main(String[] args) {
		Bird bird = new Bird(4,"红色");
		bird.introduce();
		bird.fly();
		System.out.println();
		Fish fish = new Fish(2,5);
		fish.introduce();
		fish.swimming();
	}
}