final
final 经常被称为终结修饰符，被他修饰后一般具有如下功能
- 阻止类被继承
- 阻止父类的方法被覆写
- 阻止属性被修改
- 阻止局部变量被修改
被 final 修饰的属性只能在两个位置初始化：定义时；静态代码块里面；
不要试图在构造函数里面为 final 变量赋值！！！
你没有必要在为一个 final 类下的方法设置 final 修饰
final 和 static 搭配工作效率更高哦！
抽象类
抽象类必背规则
- 抽象类不可实例化
- 抽象类可以没有抽象方法
- 类内只要存在一个抽象方法，他就必须声明为抽象类
- abstract 仅能修饰方法和类
- 抽象类内可以有任何普通类所拥有的成员
- 一个类继承了抽象类，就必须实现其中所有的抽象方法，除非这个类也是抽象类
- 抽象方法不能有函数体
- 抽象方法不可用 private，final，static 等阻止重写的修饰符来修饰
简易的根据上述知识构筑的抽象类和抽象方法实验代码
package chapter2;
public class AbstractDemo {
public static void main(String[] args) {
AbstractEntity entity = new AbstractEntity();
entity.getName();
entity.sayHi();
}
}
abstract class Abstract1 {
public abstract void getName();
public void sayHi() {
System.out.println("hw");
}
}
class AbstractEntity extends Abstract1{
@Override
public void getName() {
System.out.println("no name");
}
}
接口
接口内的静态方法、默认方法可以自带函数体，其余的函数都不可以有函数体
interface USBInterface {
public void getType();
// 默认方法
default public void defTest(){
System.out.println("default test");
}
// 静态方法
public static void staticTest() {
System.out.println("static test");
}
}
接口使用细节
- 接口不可以实例化
- 接口中的抽象方法无需加 abstract 修饰符
- 接口中所有方法均为 public
- 普通类实现接口，必须重写方法；抽象类实现接口，可以一个方法都不重写
- 一个类可实现多个接口
- 接口属性只能是 final 的
- 访问接口属性，使用格式：
接口名.属性名 - 接口可以额外继承多个其他接口
interface B extends A,C{}
接口也可以实现多态，下面展示了数组多态
package chapter2;
public class InterfaceDemo {
public static void main(String[] args) {
Device[] devices = new Device[2];
devices[0] = new Phone();
devices[1] = new Computer();
for (Device device : devices) {
if (device instanceof Phone) ((Phone) device).call();
else device.work();
}
}
}
interface Device {
void work();
}
class Phone implements Device {
@Override
public void work() {
System.out.println("phone work");
}
public void call() {
System.out.println("打电话了");
}
}
class Computer implements Device {
@Override
public void work() {
System.out.println("computer work");
}
}
接口多态传递现象
比如下方，A2 继承了接口 A1，那么我们的类实现了 A2 接口的同时也顺便实现了 A1 接口，呈现传递关系
package chapter2;
public class InterfacePolyLinkDemo {
public static void main(String[] args) {
A1 aa1 = new A();
A2 aa2 = new A();
}
}
interface A1 {
}
interface A2 extends A1 {
}
class A implements A2 {
}
内部类
局部内部类
定义于方法中，而且有类名
可访问外部类所有成员，包括私有
不可添加访问修饰符，但可以 final 修饰
作用域仅仅是方法内部
如果内部类有和外部类同名的属性或者方法，可以使用以下格式：外部类名.this.外部类属性或者方法名
package chapter3;
public class LocalInnerClass {
public static void main(String[] args) {
new LocalClass().getNum();
}
}
class LocalClass {
private int outNum = 1;
public void getNum() {
// 定义局部内部类 InnerClass
class InnerClass {
private int outNum = 2;
public void say() {
// 输出局部内部类的 outNum，即 2
System.out.println(outNum);
// 输出外部类的 outNum，即 1
System.out.println(LocalClass.this.outNum);
}
}
// 创建 InnerClass 的实例并调用 say() 方法
new InnerClass().say();
}
}
匿名内部类
定义于方法内，但是是匿名的
我们需要提供一个接口，来让匿名内部类有一个模板来参照
package chapter3;
public class AnonymousInnerClass {
public static void main(String[] args) {
new AnonymousClass().getWhatSay();
}
}
interface A {
void say();
}
class AnonymousClass {
public void getWhatSay() {
// 匿名内部类
new A() {
@Override
public void say() {
System.out.println("fuck");
}
}.say();
}
}
匿名内部类的一个重要方法是把他当做一个实参来传递，从而简化代码操作
package chapter3;
public class AnonymousInnerClass {
public static void main(String[] args) {
// 调用方法，直接传入一个匿名类实现
sayHello(new A() {
@Override
public void say() {
System.out.println("hello world");
}
});
}
// 接收一个接口作为形参
public static void sayHello(A a){
// 调用接口方法
a.say();
}
}
interface A {
void say();
}
成员内部类
直接作为外部类的一个成员出现，不被 static 修饰
他可以添加任何访问修饰符
内部类可以访问外部类所有成员，反过来也是一样的
package chapter3;
public class MemberInnerClass {
public static void main(String[] args) {
new MemberClass().sayHello();
}
}
class MemberClass {
private int num = 100;
public void sayHello() {
System.out.println("fuck");
InnerClass innerClass = new InnerClass();
System.out.println(innerClass.getNum() + innerClass.res);
}
class InnerClass {
private int res = 1000;
public int getNum() {
return MemberClass.this.num;
}
}
}
静态内部类
直接作为外部类的一个成员出现， static 修饰
跟所有被 static 修饰的成员一样，该内部类只能访问外部类的静态成员