第8章 面向对象
8.1 Java 继承
继承的概念:指子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
image.png
- 兔子和羊属于食草动物类，狮子和豹属于食肉动物类。
- 食草动物和食肉动物属于动物类。
- 继承关系属于：is-a,父类更通用，子类更具体。
- 虽然食草动物的食肉动物都属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。
类的继承格式
在java中通过 extends 关键字可以申明一个类是从另一个类继承而来的，一股形式如下：
class 父类 {
}
class 子类 extends 父类 {
}
为什么需要继承
动物实例：企鹅和老鼠。
- 企鹅：属性（ 姓名，id ）,方法（ 吃，睡，自我介绍 ）
- 老鼠：属性（姓名，id ）,方法（ 吃，睡，自我介绍 ）
企鹅类
public class Penguin {
private String name;
private String id;
public Penguin( String myName,int myid ){
name = myName;
id = myid;
}
public void eat(){
System.out.println( name + " 正在吃");
}
public void sleep(){
System.out.println( name + " 正在睡");
}
public void introduction(){
System.out.println( " 大家好！我是 " + id + " 号" + name + " 。");
}
}
老鼠类
public class Mouse {
private String name;
private int id;
public Mouse(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
从企鹅和老鼠两个类来看，代码存在重复，且维护性不高。继承就能排上用场了
公共父类
public class Animal {
private String name;
private String id;
public Animal( String myName,int myid ){
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
企鹅类
public class Penguin extends Animal {
public Penguin(String myName,int myid){
super(myName,myid);
}
}
企老鼠
public class Mouse extends Animal {
public Mouse(String myName,int myid){
super(myName,myid);
}
}
image.png
继承在的特性
- 子类拥有父类非 private 的属性 方法。
- 子类可买拥有自己属性和方法，即子类可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
继承关键字 extends 和implements
extends 关键字
在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extend 只能继承一个类。
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 关键字
保用implements关键字可以变相的使Java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
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();
}
}
final 关键字
final关键字声明类可以把类定义不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
image.png
注:实例变量也可以被定义为 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);
}
}