08.Java面向对象的继承-23/04/25

1.继承：指一个类可以派生出子类，子类继承了父类的所有属性和方法，还可以在此基础上扩展自己的属性和方法。

        注：构造方法不能被继承

        优点：继承可以提高代码的复用性，减少代码的重复编写，同时也便于代码的维护和升级。

初始化过程： 

        1. 初始化父类中的静态成员变量和静态代码块 ； 

        2. 初始化子类中的静态成员变量和静态代码块 ； 

        3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；

        4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

/**
*当一个子类继承另外一个父类，那么这个子类就可以直接拥有的父类中的公共的属性和方法
*/
class 父类{    
}
//java中通过 extends 关键字可以申明一个类是从另一个类继承而来的
class 子类 extends 父类{ 
}

  2.方法的重写：

        ①继承/实现关系

        ②子类的方法名必须与父类的方法名一致

        ③方法参数列表必须一致(参数个数、参数类型、参数顺序)

        ④方法的返回值与方法的重写有关联

        ⑤子类重写父类中方法，只能把修饰权限放大不能缩小；

3.方法重写与方法重载的区别

区别点	方法重载	方法重写
使用位置	在本类中	在继承中
参数列表	必须不同	必须相同
返回类型	可以修改	必须相同
异常	可以修改	可以减少或删除，一定不能抛出新的或更广的异常
访问	可以修改	一定不能做更严格的限制，可以降低限制

4.this和super关键字的作用：

        ①this：表示当前类对象

                可以调用当前类方法、属性、构造方法(能够用来区分成员变量与局部变量)

                调用构造方法必须在类中的第一行

public class Pig {
	String name;
	String weight;
	public Pig(){    //构造方法
		this("乔治", "60");    //用this调用自己的构造方法，只能定义构造方法的第一行
	}
	public Pig(String name, String weight){    //构造方法
		this.name = name;
		this.weight = weight;
	}
	public void showInfo() {
		System.out.println(this.name+"重量为："+this.weight+"kg");
	}
	public static void main(String[] args) {
		Pig pig = new Pig();
		pig.showInfo();
	}
}

        ②super：表示父类引用，关键字主要出现有继承关系的子类中

                可以调用父类的方法、属性、构造方法

                调用父类的构造方法必须在类中的第一行

/**
*父类
*/
public class Person {
	String name;
	public Person() {
		
	}
	public Person(String name) {
		this.name = name;
	}
	public void showInfo() {
		System.out.println("Person"+this.name);
	}
}
/**
*子类
*/
public class Teacher extends Person{
	public Teacher() {
		super();	//调用父类的无参构造
	}
	public Teacher(String name) {
		super(name);	//调用父类有参构造
	}
	public static void main(String[] args) {
		Teacher tea = new Teacher("佩奇");
		tea.showInfo();    //调用Teacher的父类方法
	}
}

5.final关键字：表示最终的意思，可以修饰类、方法、变量

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

        被final修饰的方法不能被重写；

        被final修饰的变量，初始化后，其值不可更改。

6.抽象类：一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

        由于抽象类不能实例化对象(不能被new)，所以抽象类必须被继承，才能被使用。

        规定：

                1. 抽象类不能被实例化，只有抽象类的非抽象子类可以创建对象。

                2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

                3. 抽象类中的抽象方法只是声明，不包含方法体

                4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

                5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

public abstract class Animal{    //定义一个抽象类
    public abstract void eat();    //定义一个抽象方法
}
public Dog extends Animal{    //子类
    public void eat(){    //重写父类的抽象方法
        System.out.println("吃")
    }
}

7.接口：

        一个类通过继承接口的方式，从而来继承接口的抽象方法。

                接口定义：访问修饰符 interface 接口名(){}

                子类实现接口：访问修饰符 class 类名 implemengts 接口1,接口2{}

        接口特点：

                1.接口不能用于实例化对象

                2.接口没有构造方法

                3.接口中所有的方法必须是抽象方法

                        Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。

                4.接口不能包含成员变量，除了 static 和 final 变量

                5.接口只能定义常量

                6.接口支持多继承(接口与接口之间也可以实现多继承，但是用extends关键字)

        实现接口有两种方式：

                ①实现类：定义一个子类implements接口，如果接口有方法那么重写方法；

                ②匿名内部类：直接在某个类的内部调用，语法为：接口名 a = new 接口名();   

                        如果接口有方法那么重写方法；

public interface flyAnimal {        //定义一个接口
	public abstract void Fly() ;    //定义一个抽象方法
}
public class Insect {               //定义一个父类 
	int leg = 6;
	public void spawning() {
		System.out.println("产卵中");
	}
}
public class Bee extends Insect implements flyAnimal { //继承父类，实现接口
	public void Fly() {             //重写抽象方法          
		System.out.println("蜜蜂飞");
	}
	public static void main(String[] args) {
		Bee bee = new Bee();        
		bee.Fly();
		System.out.println("蜜蜂的腿数为："+bee.leg);
		bee.spawning();
	}
}

8.接口与抽象类的相同与区别

相同：	区别：
1. 抽象类和接口都不能被实例化。	1. 接口里只能包含抽象方法，静态方法和默认方法，不能为普通方法提供方法的实现，而抽象类完全可以包含普通方法，接口中的普通方法默认为抽象方法。
	2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型且必须赋值。
	3. 接口不能包含构造器，而抽象类可以包含构造器，抽象类中的构造器并不是用于创造对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
2. 继承抽象类和实现接口都要对其中的抽象方法进行全部实现。
	4. 接口里不能包含初始化块，而抽象类里可以包含初始化块。
	5. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。