01java入门语法03-继承（super、this、重写）、接口、抽象类、接口多态，final、权限、内部类、引用类型

一、继承

如果多个类存在相同属性和行为时，将这些内容抽取到单独一个类中，无需再定义这些属性和行为。这样可以提高代码的复用性，类与类之间产生了关系，是多态的前提。
1.概述:就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。继承描述的是事物之间的所属关系。

在父子类的继承关系当中，创建子类对象，访问成员方法的规则：创建的对象是谁，就优先用谁，如果没有则向上找。无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类。

格式:

class 父类｛
			...
		｝
class 子类 extends 父类{
		...
		}

注意:

如果直接使用extends父类，可以直接使用。如果没有，必须按照相关规则进行调用。父类中的成员变量是非私有的，子类中可以直接访问。若父类中成员变量私有了，根据封装规则，使用private修饰成员变量，子类是不能直接访问的。如果要想访问父类的私有变量，可以在父类中提供公共的getXxx和setXxx方法。

特点：

继承后的特点——成员变量
①如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。②如果子类父类中出现重名的成员变量，这时的访问是有影响的。在子类中需要访问父类中非私有成员变量时， 需要使用super关键字，修饰父类成员变量，类似于之前学过的this。super.父类成员变量。
继承后的特点——成员方法
①成员方法不重名：如果子类父类出现不重名的成员方法，调用不受影响。对象调用方法时，会在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。②成员方法重名：这种情况叫做方法重写。子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。如果想调用父类成员方法，super.父类成员方法，可以调用父类的成员方法。
注意事项
①子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
②子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。
继承后的特点——构造方法
构造方法的定义格式和作用。①构造方法的名字是与类名一致的，所以子类是无法继承父类构造方法的。②构造方法的作用是初始化成员变量的，所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super(),表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

二、super和this

父类空间优先于子类对象产生。在每次创建子类对象时，先初始化父类空间，在创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定要先调用父类的构造方法。子类构造方法当中有一个默认隐含的super()调用，所以一定是先调用的父类构造，后执行的子类构造。super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。子类必须调用父类构造方法，不写则赠送super（），写了则用写的指定的super调用，super只能有一个，还必须是第一个。

super：代表父类的存储空间（可以理解为父亲的引用）。
this：代表当前对象的引用（谁调用就代表谁）。

子类的每个构造方法中均有默认的super（），调用父类的空参构造。手动调用父类构造会覆盖默认的super（）。super（）和this（）都必须在构造方法的第一行，所以不能同时出现。

三、继承的特点与方法覆盖

1.继承特点
①Java只支持单继承，不支持多继承。

class S extends A{}//ok
class S extends A,B{}//error

②Java支持多层继承体系。

class A{}
class B exends A{}
class C exends B{}
//顶层父类是Object类。所有的类默认继承Object，作为父类。

③子类和父类是一种相对的概念。

2.方法覆盖特点

①.必须保证父子类之间的方法名称相同，参数列表也相同。@Override写在方法前面，用来检测是不是有效的正确覆盖重写。
②.子类方法的返回值必须小于等于父类方法的返回值范围Object类是所有类的公共最高父类方法的返回值范围。
③.子类方法的权限必须大于等于父类方法的权限修饰符

四、接口、抽象类

父类中的方法，被它们的子类们重写，子类各自的实现都不尽相同。那么父类的方法生命和方法主体，只有声明还有意义，而方法主体则没有存在的意义了，我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
抽象方法：没有方法体的方法。
抽象类：包含抽象方法的类。
接口能够定义抽象方法。
格式：public abstract 返回值类型 方法名称（参数列表）；
注意事项：1.接口中的抽象方法，修饰符必须是两个固定的关键字：public abstract。这两个关键字修饰符，可以选择性的省略。

1.接口

普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范!自己无法写方法专业的约束!约束和实现分离:面向接口编程~
接口就是规范，定义的是一组规则。体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使。则必须能飞。如果你是汽车。则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。接口的本质是契约。就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓。是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java.c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class.声明接口的关键字是interface
作用:
1.约束，只能定义方法名
2.定义一些方法。让不同的人实现~10—>1
3. public abstract
4. public static final
5.接口不能被实例化，接口中没有构造方法~接口比抽象类更抽象
6. implements可以实现多个接口
7.子类实现接口，必须重写其中的方法
8.只有一个方法的接口叫做函数式接口,可以使用ambda表达式简化

接口就是多个类的公共规范，接口是一种引用数据类型，最重要的内容就是其中的抽象方法。定义接口格式：public interface 接口名称｛｝。换成了关键字interface之后，编译生成的字节码文件仍然是java—>class.

接口中目前可以包含常量、抽象方法、默认方法、静态方法、私有方法。接口不能直接使用，必须有一个实现类来实现该接口。
格式：public class 实现类名称 implement 接口名称｛｝。

接口的实现类必须覆盖重写实现接口中所有的抽象方法。实现：去掉abstract关键字，加上方法体大括号。创建类的对象，进行使用。
注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是实现类自己就必须是抽象类。

1.默认方法default

默认方法的使用
可以继承，也可以重写，二选一，但是只能通过实现类的对象来调用。
1）继承默认方法

//定义接口
public interface LiveAble{
		public abstract void fly(){
			System.out.println("天上飞");
			}
		}
//定义实现类
public class Animal implements LiveAble{
	//继承，什么都不用写，直接调用
	}
//定义测试类
public class InterfaceDemo{
	public static void main(String[] args){
		Animal a=new Animal();
		a.fly();
		}
	}

2)重写默认方法

//定义接口
public interface LiveAble{
		public default void fly(){
			System.out.println("天上飞");
			}
		}
//定义实现类
public class Animal implements LiveAble{
	@Override
	public void fly(){
		System.out.println("自由自在的飞");
		}
	}
//定义测试类
public class InterfaceDemo{
	public static void main(String[] args){
		//创建子类对象
		Animal a=new Animal();
		//调用重写方法
		a.fly();
		}
	}

从Java8开始，接口里允许定义默认方法。
格式：public default 返回值类型 方法名称（参数列表）｛方法体｝
接口当中的默认方法，可以解决接口升级的问题。

public interface MyInterfaceDefault｛
//抽象方法
	public abstract void methodAbs();
	//public abstract void methodAbs2();不能直接添加一个抽象方法，如果添加，其实现类必须重写。
	//如果添加则需使用默认方法
	public default void methodDefault（）｛
		System.out.println("这是新添加的方法");
｝	
｝

MyInterfaceDefaultA a=new MyInterfaceDefaultA();
a.methodAbs();//调用抽象方法，实际运行的是右侧实现类。
//调用默认方法，如果实现类当中没有，会向上找接口。
a.methodDefault();
MyInterfaceDefaultB b = new MyInterfaceDefaultB();
b.methodAbs();
b.methodDefault();

不能通过接口实现类的对象来调用接口当中的静态方法。

2.抽象类abstract使用格式
①抽象方法
使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
修饰符 abstract 返回值类型 方法名（参数列表）；
public abstract void run();
②抽象类
如果一个类包含抽象方法，那么该类必须是抽象类。
public abstract void run();
③抽象的使用
继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

注意事项:①抽象类不能创建对象，如果创建，编译报错，只能创建其非抽象子类的对象。理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。②抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。理解：子类的构造方法中，有默认的super（），需要访问父类构造方法。③抽象类中，不一定包含抽象方法，但是有抽象方法的类必须是抽象类。理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。④抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。理解：假设不重写所有的抽象方法，则类中可能包含抽象方法，那么创建对象后，调用抽象的方法，没有意义。
①非抽象子类实现接口:
1）必须重写接口中所有抽象方法。
2）继承接口的默认方法，即可以直接调用，也可以重写。
②抽象方法的使用

//定义接口
public interface LiveAble{
		//定义抽象方法
		public abstract void eat();
		public abstract void sleep();
		}
//定义实现类
public class Animal implements LiveAble{
	@Override
	public void eat(){
		System.out.println("吃东西")；
		}
	@Override
	public void sleep(){
		System.out.println("睡觉觉")；
		}
	}
//定义测试类
public class InterfaceDemo{
	public static void main(String[] args){
		Animal a=new Animal();
		a.eat();
		a.sleep();
		}

	}

3.静态方法的使用

//定义接口
public interface LiveAble{
		public static void run(){
			System.out.println("跑起来");
			}
		}
//定义实现类
public class Animal implements LiveAble{
	//无法重写静态方法
	}
//定义测试类
public class InterfaceDemo{
	public static void main(String[] args){
		LiveAble.run();
		}
	}

4.私有方法的使用

私有方法：只有默认方法可以调用。
私有静态方法：默认方法和静态方法可以调用。
如果一个接口中有多个默认方法，并且方法中有重复的内容，可以抽取出来，封装到私有方法中，供默认方法调用。
问题描述：我们需要抽取一个共有方法，用来解决两个默认方法间重复代码的问题。但这个共有方法不应该让实现类使用，应该是私有化的。解决方案：接口中允许定义私有方法。①普通私有方法解决多个默认方法之间重复代码问题。格式：private static 返回值类型 方法名称（参数列表）｛方法体｝②静态私有方法解决多个静态方法之间重复代码问题。格式：private static 返回值类型 方法名称（参数列表）｛方法体｝

//定义接口：
public interface LiveAble{
	default void func(){
		func1();
		func2();
	}
	private void fun1(){
		System.out.println("跑起来~~")
	}
	private void fun2(){
		System.out.println("飞起来~~")
	}
}

5.接口多实现
一个类可以实现多个接口的。
格式：class 类名 [exends 父类名] implements 接口名1，接口名2，接口名3…{
//必须重写抽象方法
//不重名时可以选择是否重写接口中的默认方法
//[]表示可选操作
}

1）抽象方法
接口中，有多个抽象方法时，实现类必须重写所有抽象方法，如果抽象方法有重名的，只需要重写一次。

//定义多个接口
inerface A{
		public abstract void showA();
		public abstract void show();
	}
inerface B{
		public abstract void showB();
		public abstract void show();
	}
//定义实现类
public class C implements A,B{
	@Override
	public void showA(){
			System.out.println("showA");
		}
	@Override
	public void showB(){
			System.out.println("showB");
		}
	@Override
	public void show(){
			System.out.println("show");
		}
}

2)默认方法
接口中，有多个默认方法时，实现类都可以继承使用。如果默认方法有重名的，必须重新写一次。

//定义多个接口
inerface A{
		public default void showA(){};
		public default void show(){};
	}
inerface B{
		public default void showB(){};
		public default void show(){};
	}
//定义实现类
public class C implements A,B{
	@Override
	public void show(){
			System.out.println("show");
		}
}

3)静态方法
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。
优先级问题，当一个类，不仅继承一个父类，又实现若干接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

interface A{
		public default void methodA(){
			System.out.println("AAAAAA");
		}
	}
//定义父类
class D{
		public void methodA(){
			System.out.println("DDDDDD");
		}
	}
//定义子类
class C extend D implements A{
	//未重写methodA方法
	}
//定义测试类
public class Test{
	public static void main(String[] args){
		C c=new C;
		c.methodA();
	}
}
//输出结果：DDDDDD

⑤接口的多继承
一个接口也能继承另一个或者多个接口。子接口继承父接口的方法，如果父接口中的默认方法有重名的，那么子接口需要重写一次。

//定义父接口
interface A{
	public default void method(){
	System.out.println("AAAAAAA");
		}
	}
intereface B{
   public default void method(){
	System.out.println("BBBBBBBB");
		}
}
//定义子接口：
interface D extends A,B{
	@Override
	public default void method(){
		System.out.println("DDDDDDDD");
	}
}
//子接口重写默认方法时，default关键字可以保留。
//子类重写默认方法时，default关键字不可以保留。

⑥其他成员特点
在接口中，无法定义成员变量，但可以定义常量，其值不可以改变，默认使用public static final修饰。
没有构造方法，不能创建对象，没有静态代码块。

五、多态

定义：同一行为，具有多个不同表现形式。代码当中体现多态性，其实就是一句话，父类引用指向子类对象。
父类的引用指向子类的对象 Person person =new Student();,instanceof关键，如果匹配，可以进行类型之间的转换。

格式：

父类类型 变量名 =new 子类对象（）；
变量名.方法名();
父类类型指子类对象继承的父类类型，或者实现的父接口类型。

Fu f=new Zi();
f.method();

当使用多态方法调用方法时，首先检查父类是否有方法，如果没有编译错误。如果有，执行的是子类重写后方法。
或者：接口名称 对象名=new 实现类名称（）；

//定义父类
public abstract class Animal{
		public abstract void eat();
	}
//定义子类
class Cat extends Animal{
		public void eat(){
		System.out.println("吃鱼")；
	}
}
class Dog extends Animal{
	public void eat(){
		System.out.println("吃骨头")；
	}
}
//定义测试类
pubic class Test{
	public static void main(String[] args){
		Animal a1=new Cat();
		a1.eat();
		Animal a2=new Dog();
		a2.eat();
	}
}

多态的好处：可以使程序编写的更加简单，有良好的扩展。

六、final关键字

定义
不可改变，可用于修饰类、方法和变量。
类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。
使用方式
修饰类：
final class 类名｛
｝
修饰方法：
修饰符 final 返回值类型 方法名（参数列表）｛
//方法体
｝
重写被final修饰的方法，编译就会报错。
修饰变量：
①局部变量——基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能修改。
②局部变量——引用类型
引用类型的局部变量，被final修饰后，只能指向一个变量，地址不能改，但是不影响对象内部的成员变量值的修改。
③成员变量

//显示初始化
public class User{
	final String USERNAME="张三"；
	private int age；
	}
//构造方法初始化
public class User{
final String USERNAME;
private int age;
public User(String username,int age){
	this.USERNAME=username;
	this.age=age;
}
}

七、权限修饰符

public公共的
protected受保护的
default默认的
private私有的
static
final
abstract

1.访问能力

位置	public	protected	default（空的）	private
同一类中	✔	✔	✔	✔
同一包中	✔	✔	✔
不同包的子类	✔	✔
不同包的无关类	✔
**建议：**成员变量使用private，隐藏细节。
构造方法使用public，方便创建对象。
成员方法使用public，方便调用方法。
不加权限修饰符，其访问能力与default修饰符相同。

八、内部类

1.定义
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。分为局部内部类、静态内部类、匿名内部类
2.访问特点
内部类可以直接访问外部类的成员，包括私有成员。外部类要访问内部类的成员，必须要建立内部类的对象。
3.格式
外部类名.内部类名 对象名=new 外部类型（）.new 内部类型（）；
4.匿名内部类
它的本质是一个带具体实现的父类或者父接口匿名的子类对象。
如果使用接口，则需要定义子类、重写接口的方法，创建子类对象，调用重写后的方法。
①前提：匿名内部类必须继承一个父类或者实现一个父接口。
②格式：

new 父类名或者接口名(){
		//方法重写
		@Override
		public void method(){
			//	执行语句
		}
	}

③使用方式

//定义接口
public abstract class FlyAble｛
		public abstract void fly();
	｝
//创建匿名内部类，并调用
public class InnerDemo{
	public static void main(Sting[] args){
	//等号右边：是匿名内部类，定义并创建该接口的子类对象。
	//等号左边：是多态赋值，接口类型引用指向子类对象。
	FlyAble f =new FlyAble(){
		public void fly(){
			System.out.println("我飞了")；
	}
}；
//调用fly方法，执行重写后的方法
	f.fly();
	}
}

九、引用类型用法总结

1.class作为成员变量

class Role{
	int id;
	int blood;
	String name;
}

类作为成员变量时，对它进行赋值上的操作，实际上，是赋给它该类的一个对象。

2.interface作为成员变量

接口是对方法的封装。

//法术攻击
public interface FaShuSkill{
	public abstract void faShuAttack();
}
//定义角色
public class Role{
	FashuSkill fs;
	public void setFaShuSkill(FaShuSkill fs){
		this.fs=fs;
	}
//法术攻击
public void faShuAttack(){
	System.out.print("发动法术攻击")；
	fs.fsShuAttack();
	System.out.println("攻击完毕");
	}
}
//定义测试类
public class Test｛
	public static void main(String[] args){
		//创建游戏角色
		Role role=new Role();
		role.setFaShuSkill(new FaShuSkill(){
			@Override
			public void faShuAtack(){
				System.out.println("纵横天下")；
				}
})；
		//发动法术攻击
		role.faShuSkillAttack();
		//更换技能
		role.setFaShuSkill(new FaShuSkill(){
				@Override
				public void faShuAttack(){
					System.out.println("逆转乾坤")；
		}
		})；
		//发动法术攻击
		role.faShuSkillAttack();
	}
｝

3.interface作为方法参数和返回值类型
当我们看见List接口作为参数或者返回值类型时，当然可以将ArrayList的对象进行传递或返回。

//定义方法
public static List<Integer> getEvenNum(List<Integer> list){
//创建保存偶数的集合
ArrayList<Integer> evenList=new ArrayList<>();
//遍历集合list，判断元素为偶数，就添加到evenList中
for(int i=0;i<list.size();i++){
	integer integer =list.get(i);
	if (inter %2==0){
		evenList.add(integer);
	}
}
//返回偶数集合，因为getEvenNum方法的返回值类型是List，而ArrayList是List的子类。所以evenList可以返回。
return evenList;
}
//调用方法
public class Test{
	public static void main(String[] args){
	//创建ArrayList集合，并添加数字
	ArrayList<Integer> srcList=new ArrayList<>();
	for(int i=0;i<10;i++){
		srcList.add(i);
}
//获取偶数集合，因为getEvenNum方法的参数是List，而ArrayList是List的子类，所以srcList可以传递。
List list=getEvenNum(srcList);
System.out.println(list);
	}
}

接口作为参数时，传递它的子类对象。接口作为返回值类型时，返回它的子类对象。

注意：
①向上转型：多态本身就是子类型向父类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类转换为子类引用，可以使用强制类型转换的格式，便是向下转型。
子类类型 变量名=（子类类型）父类变量名；
②instanceof关键字
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

发红包案例