Java基础知识（继承、重写、重载、抽象、接口、final关键字、内部类）

继承

继承是多态的前提，如果没有继承，就没有多态

主要解决的问题：共性抽取

在继承的关系中，“子类就是一个父类”，也就是说，子类可以被当做父类看待

创建父类的格式：

public class 父类名称{

//..........................................

}

创建子类的格式：

public class 子类名称 extends 父类名称{

//.............

}

在子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量：

​ 等号左边是谁，就优先访问谁，没有就向上找。

间接通过成员方法访问成员变量：

​ 该方法属于谁，就先用谁，没有则向上找。

局部变量：直接写成员变量名

本类的成员变量：this.成员变量

父类的成员变量：super.成员变量

在父类的继承关系中，创建子类对象，访问成员方法的规则：

创建的对象是谁，就优先用谁，如果没有就向上找

 注意事项：

无论成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类。

重写（Override）

概念：在继承关系中，方法名一样，参数列表也一样。

重载（Overload）

概念：方法名一样，参数列表不一样

方法覆盖重写的特点：创建的是子类对象，则优先使用子类方法

注意事项：

• 必须保证父子类之间方法的名称相同，参数列表也相同。
• 子类方法的返回值必须小于等于父类方法的返回值范围。
• 子类方法的权限必须大于等于父类方法的权限修饰符。

继承关系中，父类构造方法的访问特点

1、子类构造方法当中有一个默认隐含的“super（）”调用，所以一定要先调用父类构造，后执行子类构造。

2、子类构造可以通过super关键字来调用父类重载构造。

3、super的父类构造调用，必须是子类构造方法的第一语句，不能一个子类构造调用多次super。

this关键字

1、在本类的成员方法中，访问本类成员变量。

2、在本类的成员方法中，访问本类的另一个成员方法。

3、在本类的成员方法中，访问本类的另一个构造方法。

注意：

• this（…）调用必须是构造方法的第一个语句，唯一一个。

• super和this两种构造调用，不能同时使用。

  Java语言是单继承的，一个类的直接父类只能有唯一一个。**

  Java语言可以多级继承。
  
  class  A{}
  
  class   B  extends   A{}//正确
  
  class    C   extends   B{} // 正确
  

  一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类。
  
  class  A{}
  
  class   B  extends   A{}//正确
  
  class    C   extends  A{} // 正确
  

抽象

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。

接口

接口就是多个类的公共规范

接口是一种引用数据类型，最重要的内容就是其中的：抽象方法

接口的格式：

public  interface 接口名称{

//接口内容

}

• 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract

• 这两个关键字修饰符，可以选择性地省略。

接口使用步骤

1、接口不能直接使用，必须有一个“实现类”来“实现”该接口

格式：

public class 实现类名称   implements 接口名称{

//.........

}

2、接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。

实现：去掉abstract关键字，加上方法字体大括号。

3、创建实现类的对象，进行使用。

接口中定义常量：

public static final 数据类型 常量名称 = 数据值；

一旦使用final修饰，不可改变

注：1、接口当中的常量，可以省略public static final

2、接口中的常量必须要进行赋值，不能不赋值

Java9+版本中，接口的内容有：

1、成员变量其实是常量，格式：

【public】 【static】【final】 数据类型 常量名称 = 数据值；

注意：

​			常量必须进行赋值，而且一旦赋值不能改变。

​			常量名称完全大写，用下划线进行分隔。

2、接口中最重要的就是抽象方法，格式：

【public】 【abstract】返回值类型  方法名称（参数类表）；

注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

3、从java 8开始，接口允许定义默认方法，格式：

【public】  default 返回值类型  方法名称（参数类表）{方法体}

注意：默认方法也可以被覆盖类重写

4、从Java 8 开始，接口允许定义静态方法，格式：

【public】 static   返回值类型  方法名称（参数列表）{方法体}

注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5、从Java 9开始，接口了允许定义私有方法，格式：

普通私有方法：private   返回值类型  方法名称（参数类表）{方法体}

静态私有云：private  static 返回值类型  方法名称（参数列表）{方法体}

注意：private的方法只有接口自己才能调用，才能被实现类或别人使用。

使用接口时需要注意：

1、接口没有静态代码块或者构造方法的。

2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

格式：

public  class  implements   MyInterfaceA   MyInterfaceB{

//覆盖重写所有的方法

}

3、如果实现类的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。

5、如果实现类实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

6、一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先使用父类当中的方法。

final关键字

四种用法：

1、可以用来修饰一个类

2、可以用来修饰一个方法

3、可以修饰一个局部变量

一旦使用final来修饰，这个变量就不能进行更改，“一次赋值，终生不变”。

对于基本数据类型，不可变说的是变量当中的数据不可改变。

对于引用数据类型来说，不可变说的是地址值不可改变。

4、修饰一个成员变量

• 如果使用final来修饰，那么这个变量也照样是不可改变的。
• 由于成员变量具有默认值，所以用来final之后必须手动赋值，不会再给默认值了。
• 对于final的成员变量，那么使用直接赋值，要么通过构造方法赋值，二者选其一

注：
​		一个类如果是final的，那么其中所有的成员方法都不可以覆盖重写（应为没有子类）

​		当final关键字用来修饰一个方法的时候，这个方法就是最终的方法，不能进行覆盖重写。

​		对于类，方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

四种权限修饰符

	public	protected	default	private
同一个类	yes	yes	yes	yes
同一个类	yes	yes	yes	no
不同包子类	yes	yes	no	no
不同包非类	yes	no	no	no

内部类

内部类：如果一个事物的内部包含一个事物，那么就是一个类内部包含另一个类

1、成员内部类

格式：

修饰符  class  外部类名称{

​			修饰符   class   内部类名称 {

​			//.................

​			}

​			//..................

}

局部内部类：一个类定义在一个方法内部的

如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final】

原因：

1、new出来的对象在堆内存当中。

2、局部变量是跟着方法走的，在栈内存当中。

3、方法运行结束后，立刻出栈，局部变量就会立刻消失。

4、new出来的对象会在堆当中持续存在，直到垃圾回收消失。

格式：

修饰符    返回值类型  外部类名称{

​					修饰符   返回值类型  外部类方法名称（参数列表）{

​									class 局部内部类名称{

​											//............

​					}

}

匿名内部类

格式：

接口名称     对象名  =   new    接口名称（）{

//覆盖重写所有抽象方法

}；

1、new代表创建对象的动作

2、接口名称就是匿名内部类需要实现哪个接口

3、{…}这个才是匿名内部类的内容

注意事项：

1、匿名内部类，在【创建对象】的时候，只能唯一使用一次。如果希望多次创建对象，而且类的内容一样的话，那么必须使用单独定义的实现类了。

2、匿名对象，在【调用方法】的时候，只能调用唯一一次。如果希望同一个对象，调用多次方法，那么必须给对象起个名字。

3、匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】

强调：匿名内部类和匿名对象不是一回事。