目录

一、final

什么是final？

二、接口概述

 什么是接口？

与抽象类的区别

常量接口

接口传参多态

四、内部类

什么是内部类？

成员内部类

静态内部类

局部内部类

---

一、final

 

什么是final？

final从字面意思来看时最终的，不可改变的含义，它可以修饰在类、方法以及变量中

值得注意的是：final修饰类则该类不能被继承，修饰方法则该方法不能被重写，修饰变量则该变量变为常量

代码示例

/*final*/ class Animal{//不能被继承
	public /*final*/ void eat() {//不能被重写
		
	}
	
}

class Dog extends Animal{
	public void eat() {
		
	}
}

public class Test1 {
	public static void main(String[] args) {
		
	}
}

class A{
	//final修饰的成员变量，没有初始化，需要赋值
	//a.直接赋值   b.动态代码块  c.构造方法
	final String name ;/*= "b";*/
	//final修饰的静态变量——静态常量（状态值——被判断）
	//a.直接赋值  b.静态代码块
	static final int age;/* = 66;*/
	/*{
		name = "b";
	}*/
	public A() {
		name = "b";
	}
	static {
		age=33;
	}
	String sex;
}

public class Test2 {
	public static void main(String[] args) {
		final int a = 5;
		//a=5;//final修饰的基本类型变量，值不可变
		final int[] arr=new int[] {1,2,3};
		arr[0] = 66;//final修饰的引用变量，值可变
		final A aa = new A();
		//aa = new A();//final修饰引用变量，地址不可变
		aa.sex = "男";//final修饰引用变量，属性值可变
	}
}

二、接口概述

 什么是接口？

接口是指特殊的抽象类，可以看成抽象的事务，它的方法也是抽象的，需要通过实现来类完成

与抽象类的区别

同：生成class文件，不能实例化对象，作为引用类型来使用，均可调用Object方法

异：属性都是公开的静态常量，方法都是公开的抽象方法，不能有构造方法，没有代码

interface MyInter{
	//public static final:公开的静态常量
	String name = " 占山";
	
	//public abstract：公开的抽象方法
	void teat();
	
	//public MyInter() {}没有构造方法
	
	//{}没有动态代码块
	//static {没有静态代码块
}
//实现类的处理：1.将自身变为抽象  2.重写接口的抽象方法
/*abstract */class MyImpl implements MyInter{

	@Override
	public void teat() {
		
		
	}
	
}

实际应用场景，在之后的案例中会更多的使用这些场景

interface fireable{//一般把接口后缀able具备某种能力
	String name = "吴彦祖";
	void fire() ;//能力的具体体现
}
interface ITest{//标记型接口——没有抽象方法的接口	
}
interface ITest2 extends ITest,fireable{//接口的多继承
	
}

class WaWa implements fireable{//实现多个接口
	@Override
	public void fire() {
		System.out.println(" 吴彦祖会演戏");
	}
	public void eat() {
		System.out.println("吴彦祖正在吃饭");
	}
}

public class Test3 {
	public static void main(String[] args) {
		//作为引用类型来使用——多态
		//调用：
		fireable fire = new WaWa();
		fire.fire();//可以调用实现类重写的方法
		//接口引用指向实现类对象
		//但不能调用类中独有方法，强转
		if(fire instanceof WaWa) {//强转成实现类对象——强转会有隐患
			WaWa wa = (WaWa) fire;
			wa.eat();
		}
	}
}

常量接口

//常量接口：接口中，定义了静态常量
interface Inter{
	int HTTP_OK=200;//静态·常量规范
	int HTTP_ERROR=404;
}

public class Test5 {
	public static void main(String[] args) {
		int state = getPageState();
		if(state==Inter.HTTP_OK) {	
			System.out.println("成功返回页面");
		}else if(state==Inter.HTTP_ERROR) {
			System.out.println("失败的页面状态");
		}
	}
	private static int getPageState(){//当成具体实现
		return Inter.HTTP_OK;
	}
}

接口传参多态

interface USB1{
	void run();
}

class Mouse1 implements USB1{
	public void run() {
		System.out.println("鼠标正在连接电脑");
	}
}

class Disk1 implements USB1{
	public void run() {
		System.out.println("硬盘正在连接电脑");
	}
}

class Computer1  {
	public void connect(USB1 usb1) {
		usb1.run();
	}
}

public class Test1_1 {
	public static void main(String[] args) {
		Computer1 com = new Computer1();
		com.connect(new Mouse1());
		com.connect(new Disk1());
	}
}

四、内部类

 

 

什么是内部类？

在一个类的内部又包含了完整的类，它可以生成独立的class文件，可使用外部类的私有成员且不破坏封装性，可以将外部类的一些功能交给内部类完成，有成员内部类、静态内部类以及局部内部类

成员内部类

class Outter{
	private String name="张三";
	public int add(int a,int b) {
		return new Inner().addFun(a, b);//注意这两行的写法
	}
	
	class Inner{//成员内部类
		private String name="李四";
		//private int addFun(int a,int b);不能使用static
		public int addFun(int a,int b) {
		
			System.out.println(name);//输出内容优先作用域小的；用域下
			//System.out.println(Outter.this.name);//张三
			return a+b;
		}
	}
}



public class Test1 {
	public static void main(String[] args) {
		Outter.Inner inner = new Outter().new Inner();
		System.out.println(inner.addFun(4, 5));
	}

静态内部类

只需要在内部类中加上static进行修饰

class A{
	private int age = 30;
	static class B{
		static String name;
		public void show() {
			
			//System.out.println(age);因为加载时机问题，在静态内部类中不能使用外部类属性
			System.out.println("静态内部类方法的调用");
		}
	}
}

public class Test2 {
	public static void main(String[] args) {
		A.B b=new A.B();//static的资源需要类来调
		b.show();
		//简化方式
		B b2 = new B();//这里要导包才不会出错
		b2.show();
	}

局部内部类

不用加public进行修饰

class AA{
	public void show() {
		int age =10;//在局部内部类中使用局部变量时会变为常量+final
		/*局部内部类不能加public修饰*/
		class BB{//定义的局部内部类
			//只在当前方法体调用
			public void test() {
				System.out.println(age);
				System.out.println("局部内部类");
			}
		}
		new BB().test();
	}
	
}

public class Test3 {
	public static void main(String[] args) {
		new AA().show();//调用方法
	}
}