javase day10

abstract（抽象）
abstract是关键字 修饰符-----方法 类
所有的子类对父类的某个方法进行了不同程度的重写，父类的这个方法的方法体就没有实际含义了，就可以把方法体去掉了，用abstract修饰就变成了抽象方法，如果一个类中出现了抽象方法，这个类就要变成抽象类。抽象方法一定要被重写，如果一个普通类继承抽象类就要把所有的抽象方法都进行重写，如果不想进行重写就可以把普通类变成抽象类

普通方法----实体方法

抽象方法可以重载？可以重载
抽象方法可以被static/final/private分别修饰？不行，不能进行重写
抽象类一定含有抽象方法？不一定
抽象类可以创建对象？含有构造方法，其它编程语言（c）通过构造方法创建出了对象，但是这个对象对于Java而言拿不到，所以就是没有对象
抽象类可以被final修饰？ 不可以，最终类不可以被继承，重写的前提是继承

bin—binary 字节码文件–二进制

interface（接口）

public class GzDemo{
	public static void main(String[] args) {
		
}
}
//interface---接口---不是类
//接口与接口之间通过extends产生继承关系
//接口与接口直接是多继承
interface  Shape {
	
	public abstract double c();
	
	public abstract double s();
	
}
//implements----让类与接口产生关联关系：实现
//实现的方式是多实现----类可以实现多个接口
//一个普通类实现一个接口就要重写所有的抽象方法
//如果不想重写所有的方法就可以变成抽象类
abstract class Rectangle implements Shape,Cloneable{

	
	/*
	 * public double c() { return 0.0; } public double s() { return 0.0; }
	 */
}	
	
class Squarw extends Rectangle{

	@Override
	public double c() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public double s() {
		// TODO Auto-generated method stub
		return 0;
	}

	
	
}	
class Circle implements Shape{

	@Override
	public double c() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public double s() {
		// TODO Auto-generated method stub
		return 0;
	}
	
}

接口可以创建对象？不能定义构造方法，不能创建对象
接口中可以定义属性？可以定义属性 属性被public final static 默认修饰
抽象方法默认被public abstract修饰

接口类型可以接受所有类型是的转换

interface Shape1 extends Object,Cloneable{
//默认被public final static修饰
	int i=10;
	//抽象方法默认被public abstract 修饰
	void m();
	//没有构造方法
	//public Shape1(){}报错
	public abstract double c();
	public abstract double s();
}

重要：

public class InterfaceDemo1 {
	public static void main(String[] args) {
		//向上造型对象
		B b=new C();
		//编译没有错
		/**
		 * 在编译时期，针对两个对象的声明类是否有继承关系
		 * 如果有继承关系就编译通过
		 */
		//c的声明类是C类，b的声明类是B类，B类和C类有继承
		//关系编译通过
		//在运行时期，针对两个对象的实际创建
		//类是否一致，才能运行通过
		//c的实际创建类是C类，b的实际创建类是C类，一致就通过
		C c=(C) b;//向下造型--场景很少，有向上才有向下
		//ClassCastException---类型转换异常
		//编译没错，运行有错
		//D d=(D)b;
		//d=(D)C;编译报错
		//接口类型可以接受所有类型是的转换
		A a=(A)b;
		A a1=(A)c;
		
		System.out.println("over...");
	}
}
//类与类之间是树状结构，能快速检测两个类之间的关系，
//在编译和运行都进行了检测
//类与接口之间是多实现，是一个网状结构，不能快速检
//测两个类型之间的关系，在编译时期就不检测了，在运行时期
//检测类型之间是否有实现关系
interface A{
	
}
class B implements A{//既可以实现也可以继承
	
}
class C extends B implements A{
	
}
class D extends B{
	
}

接口中全部都是抽象方法？不一定，jdk 1.8以前接口中都是抽象方法，从jdk1.8开始允许在接口中定义实体方法

案例：
函数式接口-----functional Interface

public class InterfaceDemo2 {

	public static void main(String[] args) {
	    
		//Lambda表达式从1.8开始支持的
		//（参数列表）->{重写方法的方法体}
		//Calc c=(int m,int n)->{return m>n?m:n;};
		//如果方法只有一行代码就可以省略return 以及{}
		//Calc c=(int m,int n)->m>n?m:n;
		//有接中的抽象方法可以推导出参数类型，在此时可以不用类型表示
		Calc c=(m,n)-> m>n?m:n;
		System.out.println(c.max(4, 7));
	}
}
//代表计算器接口
//如果想要使用lambda表达式需要保证接口中只有一个抽象方法
//函数式接口---只有一个方法的接口
//functionalInterface
interface Calc{
	//最大值
	//抽象方法
	 int max(int m,int n);
	//求和
	//实体方法-----被default修饰---默认实体方法
	public default int sum(int m,int n ) {
		return m+n;
	}
	//求乘积
	//实体方法-----被static修饰----静态实体方法
	public static int cj(int n,int m) {
		return n+m;
	}
	
}

案例2：函数式接口（数组）

public class InterfaceDemo3 {

	public static void main(String[] args) {
		int[]arr= {1,6,2,8,7};
		//Arrayx a=(int[]arr1)->{ Arrays.sort(arr1);};
		//Arrayx a=(arr1)->{Arrays.sort(arr1);};
		//Arrayx a=(arr1)->Arrays.sort(arr1);
		//一个参数可以去括号
		//Arrayx a=arr1->Arrays.sort(arr1);
		//::表示传递的是静态的方法
		Arrayx a=Arrays::sort;
		a.sort(arr);
		System.out.println(Arrays.toString(arr));
	}
}
interface Arrayx{
	//对数组排序的抽象方法
	void sort(int[]arr1);
}

jdk在接口中的新特性
可以在接口中定义实体（default、static），
通过lambda表达式对接口中的抽象方法进行重写，保证接口中只有一个抽象方法
一个接口中只有一个抽象方法----函数式接口

接口的优点：
1、约束、模板
2、向上造型的类型统一（接口类型）

内部类
定义：类或接口中再来一个类

类中再定义一个类

方法内部类：
在方法中定义一个类，可以定义非静态的属性、方法及静态常量，可以继承和实现，不能被访问修饰符修饰，可以被final和abstract修饰，可以获取外部类的所有属性和方法，只能拿到本方法总的常量

public class InnerDemo1 {
	public static void main(String[] args) {
		Outer1 out=new Outer1();
		out.m(); 
	}
}
class Outer1{
	//属性
	int j=1;
	private int a=2;
	//方法
	public void m() {
		//方法内部类
		//非静态的属性和方法以及静态常量
		//可以继承和实现
		//不能被访问权限修饰符修饰，可以被final和abstract修饰
		//内部类可以获取外部类的所有信息
		int  x=2;//jdk1.8特性 隐式常量，默认在底层加final
		//jdk1.8以前显示常量，必须手动添加final
		//内部类获取本方法中的信息一定是常量
		class Inner1 extends Object implements Cloneable{
			static final int i=10;
			public void mn() {
				System.out.println(j+a);
				System.out.println(x);
				n();
			}
			
		}
		//创建对象及调用方法
		/*
		 * Inner in=new Inner();in.mn();
		 * */
		new Inner1().mn();
	}
	public void n() {
		
	}
}

成员内部类：
在类内方法外再定义一个类，可以定义非静态属性、方法和静态常量，可以继承和实现，可以被访问权限修饰符和final及abstract修饰，可以拿到外部类的所有属性和方法
Outer2.Inner2 in=new Outer2().new Inner2();

public class InnerDemo2 {
	public static void main(String[] args) {
		Outer2.Inner2 in=new Outer2().new Inner2();
		in.n();
	}
}
class Outer2{
	//属性
	int x=1;
	//成员内部类
	//可以定义非静态属性和方法以及静态常量
	//可以继承与实现，可以被访问权限修饰符修饰 以及被final和abstract修饰
	//可以拿到外部类的所有信息（属性和方法）
	//Person person=new Person();
	class Inner2 extends Object implements Cloneable{
		int i=1;
		static final int a=6;
		public void n() {
			System.out.println(i+" "+x);
			m();
		}
	}
	//方法
	public void m() {
		
	}
	
}

静态内部类：
成员内部类加上static，可以定义任意信息，可以继承和实现，可以被访问权限修饰符和final及abstract修饰，只能获取外部的静态信息，Outer3.Inner3 in=new Outer3.Inner3();

class InnerDemo3 {
	public static void main(String[] args) {
		Outer3.Inner3.mn();
		//静态内部对象
		Outer3.Inner3 in=new Outer3.Inner3();
				in.mn2();
	}
}
//外部类
class Outer3{
	static int i=1;
	//静态内部类
	//可以定义任意信息以及静态常量
	//可以继承与实现
	//可以被访问权限修饰符及abstract和final修饰
	//只能读取到外部的静态信息
	//
	static class Inner3 extends Object implements Cloneable{
		static final int a=2;
		int b=1;
		static int  c=3; 
		public static void mn() {
			System.out.println(a);
			System.out.println(i);
			m();
		}
		public void mn2() {
			System.out.println(a);
		}
	}
	public static void m() {}
	public void n() {}
}

匿名内部类：
{}----用于继承或实现接口，重写方法，如果匿名内部类在方法内就按方法内部类来使用，如果在成员内就按成员内部类来使用

public class InnerDemo4 {
	public static void main(String[] args) {
		int j=2;
		//创建对象
		//匿名内部类------{}
		//匿名内部类在继承类（可以继承）/实现接口----重写方法
		//如果匿名内部类所在的位置在方法内就可以按照方法内部类来使用
		//如果匿名内部类在成员位置就按照成员内部类来使用
		D2 d=new D2() {
			int  i=10;
			@Override
			public void m() {
				// TODO Auto-generated method stub
				System.out.println(i+" "+j);
			}
		};
		//{}---匿名内部类继承c类
		C2 c=new C2() {};
		//{}---匿名内部类实现接口
		B2 b=new B2(){};
	}
}
abstract class D2{
	public abstract void m() ;
}
class C2{
	//匿名内部类在成员位置
	B2 b2=new B2() {
	};
}
interface B2{}

接口中的内部类默认静态

public class InnerDemo5 {

	public static void main(String[] args) {
		System.out.println(A2.Inner5.i);
		System.out.println(A2.B3.c);
	}
}
interface A2{
	//默认是静态的内部类被static修饰
	static class Inner5{
		static int i=10;
	}
	//默认被static修饰
	interface B3{
		int c=12;
	}
}

内部接口
在类或接口中再来一个接口