JAVA学习——DAY3（类的扩展）

接口

• 接口的定义：
  接口声明了一组能力，指明该接口能够做什么？它依赖一组对象——实现该接口，同时，它还与另一个对象交互——使用该接口；

• 接口的实现：
  1.接口用interface关键字实现，修饰符一般为public，interface后面跟接口名称
  2.接口内的方法修饰符默认是public abstract，可不写，方法只有定义无方法体
  3.接口增强：
  （1）接口静态方法：可以定义方法体，使用修饰符static
  （2）接口默认方法：利用关键字default+方法定义

• 接口代码实现：

//这个是接口定义
/*静态方法，默认方法是java8之后的增强功能，可以根据自己需求添加,也可以在实现类修改它；
java8中默认静态方法和默认方法的修饰符是public，之后版本增加了private修饰符，
所用是便于多个静态或者默认方法复用代码（没理解为什么只有private如此）
*/
public interface Inter1{
	//接口方法
	[public abstract] void A1();
	[public abstract] void A2();
	//静态方法
	public static void B(){
		System.out.println("这是静态方法");
		}
	//默认方法
	default void C(){
		System.out.println("这是默认方法");
		}
}

//这里定义接口实现类
//利用关键字implements
[修饰符] class T implements  Inter1{
	@Override
	public void A1(){
		System.out.println("这是方法1");
		}
	@Override
	public void A2(){
		System.out.println("这是方法2");
		}
	//记住类中需要实现所有接口中定义的方法，否则会报错(静态方法和默认方法除外）
}

//接口的使用
public class Test{
	public static void main(String[] args){
		//注意：接口不能创建对象，但可以作为数据类型，对象只能通过实现类来创建
		Inter1 In=new T();
		In.A1();
		In.A2();
		//Java-8允许在接口内定义静态方法，但仅通过接口名称限制它的调用：
		Inter1.B();
		In.C();
		}
}

• 多接口实现
  1.一个类可以实现多接口，表明类的对象有多个接口的能力，各个接口用逗号隔开public class Test implements Inter1,Inter2,Inter3{}
  2.一个类实现多个接口时，这种类型的对象可以赋值给任意接口类型的变量
• 接口细节
  1.接口变量：如public static final int a=0; 其中，public static final 可以不写，即使不写也是 public static final;变量可以通过 (接口名.变量名）形式使用
  2.接口继承：接口变量可以多继承，与类继承方式相似

//接口1
public interface Inter1{};
//接口2
public interface Inter2{};
//接口3，继承接口
public interface Inter3 extends Inter1,Inter2{}

	3.类的继承与接口同在：即，一个类既可以继承其他类又可以同时实现接口	

public class Child extends Father implements Inter{}

	4.instanceof关键字：可以判断某对象是否实现了某接口

Point p=new Point();
if(p instanceof Inter){}

抽象类

• 概念
  与接口相似，抽象类定义了一些方法，却未定义如何实现，只有子类继承后才定义其实现；其类称为抽象类，其方法成为抽象方法

• 一些细节
  1.抽象类与具体类区别：抽象类不能创建对象，而具体类可以
  2.定义了抽象方法其类必定是抽象类；但定义了抽象类未必有抽象方法
  3.抽象类可以具有具体方法，实例变量
  4.抽象类与具体类的区别：抽象类不能创建对象，但具体类可以创建对象

• 为什么需要抽象类
  接口定义了能力，但未定义具体如何实现，抽象类则实现接口的能力即写具体方法；但由于抽象类不能创建对象，所以需要子类继承抽象类，即，也作为接口的实现，一般情况下子类继承抽象类的默认方法给予对象相应的能力，但如果该能力的实现方式临时变换，则只需要重写子类的该方法实现，无需动默认实现；这个很好的保护了接口能力。

内部类

• 定义：内部类定义在类的内部，可以很好的对外实现完全隐藏，可以有更好的封装性；注意：但它经过编译时会单独编译出来生成字节码文件
• 静态内部类：

public class A{
	public static int a=1;
	public void A1(){
		System.out.println("外部方法");
		}
	//静态内部类只能使用外部静态变量和方法，但不能访问成员方法和成员变量
	//静态内部类可以定义静态变量，静态方法，成员变量，成员方法构造函数等
	public static class B{
		public int b=2;
		System.out.println("使用外部变量:"+a);
		}
	public void test(){
		B si=new B();
		System.out.println("访问内部类变量:"+si.b);
		}
}

public静态内部类可以在外部使用，使用方法如下：

外部类名.内部类名  变量名=new 外部类名.内部类名（）；

• 成员内部类

public class A{
	public static int a=1;
	public void A1(){
		System.out.println("外部方法");
		}
	//定义成员内部类，与静态内部类不同，它没有static修饰符
	//成员内部类除了静态变量和静态方法，成员内部类可以访问外部成员变量和成员方法
	public class B{
		public int b=2;
		public void t1(){
		System.out.println("使用外部变量:"+a);
		}
		//成员内部变量利用外部类名.this.外部方法名调用外部方法
		B.this.action();
		}
	//外部类使用内部类时需要创建对象
	public void test(){
		B si=new B();
		System.out.println("访问内部类变量:"+si.b);
		}
	public void action(){
		System.out.println("我要动了");
		}
}

	在外部访问成员内部类时，与静态内部类不同，具体如下：

//需要先创建外部类对象，再引用成员元内部类
A outer=new A();
A.B inner=outer.new B();

• 方法内部类

public class Outer{
	private int a=1;
	//方法内部类的方法参数java8前必须是final修饰，之后虽然不做要求，当时不能修改变量
	public void test( final int b){
		final String str="hello";
		class inner{
			public void action(){
				System.out.println("这是方法内部类"):
				}
			}
		Inner inner=new Inner();
		inner.action();
}

• 匿名内部类
  暂时未学习

• 枚举
  暂时未学习