抽象类 接口 内部类 包

本文主要是关于抽象类 接口 内部类 包的讲解

抽象类和抽象方法：
1.修饰符abstract只能修饰方法和类
2.如果所有的子类对父类某个方法都进行了不同程度的重写
那么此时认为这个方法的方法体就没了实际意义，把方法体去掉用
3.abstract修饰变成抽象方法，如果有抽象方法，那么这个类就变成抽象类。
**如果一个普通类继承了抽象类，那么就要重写所有的抽象方法
如果不想重写，那么就要改变类为抽象类即抽象类继承抽象类
4.抽象类不一定有抽象方法 ，抽象类不能创建对象。因为抽象类的构造方法在底层由其他语言进行创建的。
抽象方法可以重载，但不可以被private final static修饰，抽象类不能被 final修饰，重写的前提是继承。
5.静态方法与类同级，重写与对象同级

接口：
如果这个抽象类所有的方法都是抽象方法，那么可以把这个类注意定义为接口。
注意：接口不是类
普通类通过implements关键字和接口产生了实现关系如果一个类实现了这个接口，就要实现所有里面所有的抽象方法，如果 不想都重写，就把它变成抽象类。
类与接口可以有多实现
接口与接口之间是多继承
注意：
1.接口可以创建对象么？不可以：不能有构造方法，创建不了对象
2.接口与接口之间是多继承，如果继承的含有相同的方法，并且方法的返回值不一样，那么要慎用
3.赋值过程分编译和运行，在编译时期会查看两个对象的声明类是否有
继承关系，在运行时期会查看两个对象的实际创建类是否一致，
类与类之间是 树状结构。可以快速确定类与类之间的关系，所以可以在编译时期可以检测，
接口与接口之间是多继承关系，是网状结构，不能确定之间的关系，所以接口在赋值编译时期不会进行检验。
接口可以统一类的形式
#java所有类型的对象都可以对接口进行赋值，编译时期都没有错，运行时期
查看的是实际创建类与接口之间是否有实现关系

public class InterfaceDemo2 {
	
	public static void main(String[] args) {
		//向上造型
		B b=new C();
		
		//赋值过程分编译和运行
		//在编译时期会查看两个对象的声明类是否有继承关系
		//b的声明类是B类，c的声明类是C类有继承编译通过
		//在运行时期会查看两个对象的实际创建类是否一致
		//b对象实际创建类是C类，c的实际创建类是C类一致
		C c=(C)b;
		
		//ClassCastException---类型换行异常
		//编译时期b的声明类是B类，d的声明类是D类有继承
		//运行时期b的实际创建类是C类，d的实际创建类是D类不一致
		D d=(D)b;
		
		//编译时期c的声明类是C类，d1的声明类是D类，没有继承关系
		//D d1=(D)c;
		
		//类与类之间是单继承，是树状结构可以快速确定
		//类与类之间的关系所以需要在编译时期加上检测
		//接口与接口之间是多继承，是网状结构不能快速的确定之间的关系
		//所以接口在赋值的编译时期不会进行检测
		A a=(A)b;
		A a1=(A)c;
		A a2=(A)d;
		//
		System.out.println("over");
		//System.out.println(A.i=2);
	}

}

4.接口可以定义属性和方法么？属性：可以，默认被破public final static 修饰
方法：默认被public abstract共同修饰
5.接口不是类，但底层还是.class文件
6.接口中是否都是抽象方法？不一定 jdk1.7只能是抽象方法，jdk1.8之后允许定义抽象方法和实体方法
**jdk1.8 的新特性：**1.允许定义实体方法（default 和static修饰（不是默认））
2.Lambda表达式：目的是重写抽象方法 写法：（参数列表）->{方法体}方法体 （
接口中只有一个抽象方法）
Lambda表达式写法见代码下面–方法体只有一句话的时候可以省略大括号，只有
一个参数的时候可以把小括号省略
3.接口中只有一个抽象方法就是函数式接口–函数
import java.util.Arrays;

public class InterFaceDemo4 {
	public static void main(String[] args) {
		int[] arr1={1,6,2,5,4};
		//
		//ArraySort as=(int[] arr)->{Arrays.sort(arr);};
		//方法体只有一句话的时候可以省略{}
		//ArraySort as=(int[] arr)->Arrays.sort(arr);
		//把类型去掉，可以根据接口的参数倒推
		//只有一个参数地时候可以把()省略
		//ArraySort as=arr->Arrays.sort(arr);
		//::---“的”的意思  静态方法
		ArraySort as=Arrays::sort;
		//排序
		as.arraySort(arr1);
		System.out.println(Arrays.toString(arr1));
	}
}


@FunctionalInterface
interface ArraySort{
	//
	void arraySort(int[] arr);
}

内部类：
就是类结构的一种扩充
分类：局部（方法）内部类 成员内部类 静态内部类 匿名内部类
方法内部类：
能定义非静态的属性和方法，允许定义静态常量，即final static int i=1；
可以继承和实现
不能使用访问权限修饰符但可以使用final 和abstract修饰
可以拿到外部类所有的属性和方法，对于局部变量为默认隐式常量，不能改变–在jdk1.8以后才有
方法内部类中的对象不能在其它方法里创建，但可以在该方法内部类的外部创建，并且可以调用内部类的方法和属性
成员内部类：
只能定义非静态的属性和方法
可以使用访问权限修饰符
可以被final和abstract修饰
可以继承和实现
可以拿到外部类的属性和方法
成员内部类的创建：例如： Outer2.Inner2 in=new OUter2（）.new Inner2（）；
静态内部类：
在成员内部类内加上static
可以定义所有属性和方法 可以定义静态常量
能继承和实现
可以被访问权限修饰符修饰
只能拿到外部类的静态属性和方法
静态内部类对象的创建：Outer3.Inner3 in=new Outer3.Inner3（）；
A.B.i A可以是对象 B是对象 i是B对象的属性
A是类，B是静态对象 i是B对象的属性
A是外部类，B是静态内部类，i是内部类的静态属性
匿名内部类：
{} 就是内部类所有的内容A a=new A（）{}；
匿名内部类的作用就是重写方法
匿名内部类默认继承了抽象类然后去重写
如果这个类可以被继承，那么这个类就具有内部类的形式：final不能
被继承
如果接口能被实现，就能匿名内部类（接口中的static方法只能通过类名调用
，default方法通过匿名内部类创建的对象调用）Runable run =new Runnable(){};
匿名内部类允许定义非静态属性，如果匿名内部类在方法中就和方法内部类使用
一致，如果在成员位置就和成员内部类使用一致。

内部接口:
（类中定义接口，接口中定义接口，接口都是静态的）
接口中也能定义类，且应当是静态的

包：

声明包：在首行
导入包–不在首行，可以有多个
.*可以匹配下一级位置，并不是所有的
java（java源生包）
javax（扩展包）
org（第三方厂商）
.lang–使用的时候，不需要导入包，在程序启动的时候回默认把lang包下的内容直接加载
到方法区—核心类库
.util–用于操作类或者对象的工具
.applet–小型应用程序
.awt–窗口
.beans—类
.io数据流的问题
.math–简单的数学运算
.net–网络
.nio高并发
.security–安全
.sql–操作数据库
.text 格式化的意思