【JavaSE】面向对象 --- 继承、final、抽象类、abstract、接口、多态

一.继承extends

1.概述

一个类继承另一个类，形成父子关系，子类可使用父类的成员。

2.特点

• 一个类只能继承一个父类
• 除了构造方法外，子类可以继承父类非私有的成员(包括静态成员)
• 子类需要调用父类同名成员或父类构造方法，需要使用super. 前缀进行调用
• 如需在构造方法中显式调用另一个构造方法（重载构造方法或父类构造方法），则该调用命令必须是构造方法体的第一行代码(即只能显式调用一个构造方法)。
• 如果在构造方法中调用一次本类的其他构造方法, 则还是先默认执行super();如果在构造方法中调用父类的构造方法，则不再默认执行super();。如果子类构造方法中没有显式调用父类构造方法，则子类构造方法都默认调用父类的无参构造方法super() 。

二.final

1.概述

final表示不可变，所修饰的成员都是不可更改的，防止一切可能被改变的手段。

2.修饰

• 变量

  • final修饰的变量是常量，只能被赋值一次(基本类型是值不变，引用类型是指向地址不变)
  • 类中的静态属性，必须在声明时、构造方法、构造代码块其中一处中赋值，否则会编译错误
  • 接口中的属性必须声明时赋值

• 方法

  • final修饰的方法不能被重写(因为重写方法就是改变父类方法)

• 类

  • final修饰的类不能被继承(一旦继承就可能被重写覆盖)

三.抽象类abstract

1.概述

abstract表示抽象的，需要被具体实现。

2.修饰

• 变量

  • 变量不可被abstract修饰

• 方法

  • abstract修饰的方法是抽象方法
  • 抽象方法不能有方法体
  • 抽象方法必须存在于抽象类或接口中，不能存在于普通类
  • 父类抽象方法需要被子类重写或者继续被子类声明为抽象方法

• 类

  • abstract修饰的类是抽象类
  • 抽象类中可以有多个抽象方法，也可以没有抽象方法
  • 抽象类不能被实例化，只可以被继承
  • 子类继承抽象类解决方式选择
    • 子类实现所有父类的抽象方法
    • 子类声明为抽象类，子类所继承的抽象方法可实现或不实现

四.接口interface

1.概述

接口是一种规范，一种扩展，可以看成一个全抽象的类。

2.成员

• 属性

  • 接口属性只能是公有的静态常量(默认以public static final修饰)
  • 接口属性必须在声明时同时赋值

• 方法

  • 接口中的方法只能是公有的抽象方法(默认以public abstract修饰)
  • 不能用static修饰接口方法

• 构造方法

  • 接口没有构造方法，不能被实例化，只能被实现接口

3.修饰

• 特点
  • 一个类可以实现多个接口
  • 实现接口必须实现接口中所有的抽象方法或者把类声明为抽象类
  • 一个接口可以继承多个接口

五.抽象类与接口区别

1.成员区别

• 抽象类

  • 属性可以是变量，也可以是常量
  • 抽象类中可以有多个抽象方法，也可以没有抽象方法
  • 抽象类中有构造方法

• 接口

  • 属性只能是共有的静态常量，在声明时必须同时赋值
  • 接口中所有方法都必须是公有的非静态抽象方法
  • 接口没有构造方法

2.关系区别

• 抽象类

  • 一个抽象类只能继承一个类

• 接口

  • 一个接口可以继承多个接口
  • 一个类可以实现多个接

3.设计理念区别

• 抽象类

  • 抽象类是为了重复使用资源，体现了共享性

• 接口

  • 接口是一系列的规范，体现了扩展性

六.多态

1.概述

一种事物有多种表现形式，不同的实现会进行不同的操作

2.前提

• 继承父类或实现接口
• 重写方法
• 父类(或接口)引用指向子类对象

3.向上转型

• 说明

  • 父类引用指向子类对象地址

• 特点

  • 编译看左边，运行看右边
  • 被重写的非静态方法，实际调用的是子类重写方法，其他成员都是调用父类的
  • 不能调用子类属性和特有的方法

4.向下转型

• 说明

  • 把向上转型强转为实际子类对象

• 特点

  • 可以调用子类的所有非私有成员

• 注意

  • 向下转型强转类型必须是实际执行子类的对象的类型，可以使用子类对象名 instanceof 子类 进行判断。

5.多态优缺点

• 优点

  • 提高代码维护性
  • 提高代码扩展性

• 缺点

  • 不能使用子类对象特有的成员

6.例子

• 例子1

package com.polymorphic;

public class Test1 {
	public static void main(String[] args) {
		//声明为A接口类型，指向的是子类C对象地址
		A a=new C();
		
		//输出：1
		System.out.println(a.num1);
		//输出：我是C的print1
		a.print1();
		
		//声明为父类B，指向的是子类C对象地址
		B b=new C();
		//输出：2
		System.out.println(b.num2);
		//输出：3
		System.out.println(b.num3);
		//输出：我是C的print2
		b.print2();
		
		//向上转型是无法访问子类的静态方法的
		//输出：我是B的print3
		b.print3();
		
		//判断b是否C类的对象
		if(b instanceof C){
			//向下转型
			C c=(C)b;
			
			//向下转型可以访问子类特有的成员
			//输出：我是C的print3
			c.print3();
			//输出：我是C的print4
			c.print4();
			//输出：0
			System.out.println(c.num2);
			
		}
		
		/*
		 * 输出结果
		  	1
			我是C的print1
			2
			3
			我是C的print2
			我是B的print3
		 */
	}
}

interface A{
	int num1=1;
	void print1();
}
class B{
	int num2=2;
	static int num3=3;
	public void print2(){
		System.out.println("我是B的print2");
	}
	
	public static void print3(){
		System.out.println("我是B的print3");
	}
}

class C extends B implements A{
	int num2=0;
	@Override
	public void print1() {
		System.out.println("我是C的print1");		
	}
	
	public void print2(){
		System.out.println("我是C的print2");
	}

	public static void print3(){
		System.out.println("我是C的print3");
	}
	public void print4(){
		System.out.println("我是C的print4");
	}
}

• 例子2

package com.polymorphic;

public class Test2 {
	public static void main(String[] args) {
		print(new Cat());
		print(new Dog());
		print(new Bird());
	}
	
	//多态常用于方法参数
	//参数类型声明为接口类型，传递进来的实参是什么宠物就记录该宠物的进食记录
	//只需定一个打印宠物进食记录方法，不用每种宠物记录都定义一个方法，比较简便好维护
	public static void print(Animal a){
		System.out.println("=====宠物进食记录=====");		
		a.eat();
		System.out.println("====================");
	}
}

interface Animal{
	void eat();
}

class Cat implements Animal{
	@Override
	public void eat() {
		System.out.println("吃猫粮");
				
	}	
}

class Dog implements Animal{
	@Override
	public void eat() {
		System.out.println("吃狗粮");		
	}	
}

class Bird implements Animal{
	@Override
	public void eat() {
		System.out.println("吃鸟食");		
	}	
}