版权声明：如需转载或引用请声明原文网址 https://blog.csdn.net/u013087359/article/details/81047301
一.继承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("吃鸟食");
}
}