Java 继承
就是子类继承父类的特征和行为，使得子类对象实例具有父类实例域和方法。
- 生活中的继承
- 类的继承格式
- 为什么需要继承
- 继承类型
- 继承特性
- 继承关键字
- extends
- implements
- super和this关键字
- fianl
- 构造器
生活中的继承
兔子和羊都是食草动物，狮子和老虎都是食肉动物
所以继承需要符合的关系是：is-a 父类通用，子类具体
子类也会有自身的特性或者个性
类的继承格式
- extends关键字
语法格式：
class ParentName{
}
//子类
class ChildName extends ParentName{
}
为什么需要继承
例如，需要建立两个模型
- 张三
- 属性： id，姓名，年龄
- 方法： 吃饭，睡觉，打豆豆
- 李四
- 属性： id，姓名，年龄
- 方法： 吃饭，睡觉，打豆豆
示例：
//张三
public class Zhang {
private String name;
private int id;
private int age
public Zhang(String myName, int myid ,int myAge) {
name = myName;
id = myid;
age = myAge
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void dadoudou() {
System.out.println("大家好！我是" + id + "号" + name + "."+"我在打豆豆");
}
}
//李四
public class Li {
private String name;
private int id;
private int age
public Li(String myName, int myid ,int myAge) {
name = myName;
id = myid;
age = myAge
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void dadoudou() {
System.out.println("大家好！我是" + id + "号" + name + "."+"我在打豆豆");
}
}
代码重复
提取公有属性和方法
public class Person {
private String name;
private int id;
private int age;
public Person(String myName, int myid,int myAge) {
name = myName;
id = myid;
age = MyAge;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + "."+"我在打豆豆");
}
}
继承公有父类代码
public class Zhang extends Person {
public Zhang(String myName, int myid,int myAge) {
super(myName, myid,myAge);
}
}
继承类型
java不支持多继承但支持多重继承
继承特性
- 子类拥有父类非private 的属性 、 方法
- 子类可以拥有自己的属性和方法，即子类可以对父类扩展
- java 的继承是单继承，但可以多重继承
- 提高了类之间的耦合性（就是代码之间的练习紧密，独立性差）
继承关键字
继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
extends
一个extends只能继承一个父类
示例：
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}
public class Penguin extends Animal{
}
implements
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}
super和this关键字
super：实现对父类成员的访问。引用当对象父类
this：指向自己的引用
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
fianl
可以把类定义为不能继承，即最终类；或者用于修饰方法，使其不能被子类继承
- 声明类
final class 类名{//类代码块} - 声明方法
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
注意:实例变量也可以被定义为final，被定义为final变量不能被修改。被声明为final类的方法自动的声明为final，但是实例变量并不是final
构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
示例
class SuperClass {
private int n;
SuperClass(){
System.out.println("SuperClass()");
}
SuperClass(int n) {
System.out.println("SuperClass(int n)");
this.n = n;
}
}
// SubClass 类继承
class SubClass extends SuperClass{
private int n;
SubClass(){ // 自动调用父类的无参数构造器
System.out.println("SubClass");
}
public SubClass(int n){
super(300); // 调用父类中带有参数的构造器
System.out.println("SubClass(int n):"+n);
this.n = n;
}
}
// SubClas2 类继承
class SubClass2 extends SuperClass{
private int n;
SubClass2(){
super(300); // 调用父类中带有参数的构造器
System.out.println("SubClass2");
}
public SubClass2(int n){ // 自动调用父类的无参数构造器
System.out.println("SubClass2(int n):"+n);
this.n = n;
}
}
public class TestSuperSub{
public static void main (String args[]){
System.out.println("------SubClass 类继承------");
SubClass sc1 = new SubClass();
SubClass sc2 = new SubClass(100);
System.out.println("------SubClass2 类继承------");
SubClass2 sc3 = new SubClass2();
SubClass2 sc4 = new SubClass2(200);
}
}