abstract关键字--- interface（接口）---内部类---方法内部类---成员内部类---静态内部类---匿名内部类

abstract（抽象）

关键字，修饰符 方法、类
1.概念
当所有的子类对父类的某个方法都进行不同程度的重写，那么这个方法的方法体没有实际含义就可以把方法体去掉加上abstract关键字修饰方法—抽象方法。一个类中如果出现抽象方法那么这个类就要变成抽象类。普通类继承抽象类需要重写所有的抽象方法，如果不想抽象所有的抽象方法可以把普通类变成抽象类。
注意：
1.抽象方法可以重载？可以重载
2.抽象类里一定含有抽象方法？不一定
3.抽象类中可以定义属性以及普通方法？可以
4.抽象类可以定义构造方法？可以
5.抽象类可以创建对象？抽象类没有对象的
6.抽象方法可以被private/static/final单独修饰？不可以 因为抽象方法一定重写
7.抽象类可以被final修饰？不可以 最终类不能被继承
8.抽象类目的就是为了延展类的继承结构

public class AbstractDemo1{
	public static void main(String[]args){
	//对象是匿名内部类的对象
	Shapes=new Shape(1,2){
	@Override
	public double getGirth(){
	return 0;
	}
	};//匿名内部类
	}
	}
	//代表图形的类
	//当类中出现抽象方法时类要变成抽象类
	abstract class Shape{
	//私有化属性
	private double x;
	private double y;
	//提供构造方法来进行属性初始化
	public Shape (double x,double y){
	this.x=x;
	this.y=y;
	}
	//提供get方法
	public double get X(){
	return x;
	}
	public double get Y()
	{
	return y;
	}
	//提供求周长和面积的方法
	//抽象方法---1.没有方法体2.一定要重写
	public abstract double getGirth();
	//重载抽象方法
	//public abstract double getGirth(int i);
	//普通方法---实体方法
	public double getArea(){
	return 0.0;
	}
	}
	//代表矩形的类
	//当普通类继承抽象类需要重写所有的抽象方法
	//如果普通类不想重写抽象类中所有的抽象方法可以变为抽象类	
	abstract class Rectangle extends Shape{
	public Rectangle(double x,double y){
	super (x,y);
	}
	//重写求周长和面积的方法
	/*public double getGirth(){return2*(getX()+getY());}*/
	public double getArea(){
	return get X()*get Y();
	}
	}
	//代表正方形的类
	class Square extends Rectangle{
	public Square(double x){
	super(x,x);
	}
	//重写求周长的方法
	public double getGirth(){
	return 2*(getX()+getY());
	}
	}
	//代表圆形的类
	class Circle extends Shape{
	public Circle(doubler){
	super(r,r);
	}
	//重写求周长和面积的方法
	public double getGirth(){
	return 2*3.14*getX();
	}
	public double getArea(){
	return 3.14*getX()*getX();
	}
	}

interface（接口）

1.概念

当抽象类中所有的方法都是抽象方法时可以把抽象类变成接口来表示（用interface）。接口本质不是一个类，类和接口之间通过implements产生关联关系—实现。java支持接口与接口之间是多继承，类与接口之间是多实现就是为了实现类能具有更多丰富的功能。实现类需要重写接口所有的抽象方法但是如果不想都重写需要把实现类变成抽象类。

注意：

1.接口里的方法都是抽象方法？接口里的方法都是抽象方法（和版本有关系）
2.接口里可以定义构造方法？不能定义
3.接口可以创建对象？不能
4.接口里可以定义属性？可以定义 属性默认是被public final static共同修饰 抽象方法默认被public abstract共同修饰
5.接口声明对象在编译时期可以接收所有的类型对象的赋值，但是在运行时期检测对象实际创建类是否是接口的实现类。
6.接口的目的是让实现类注入更多的特性

import java.io.Serializable;
 
public class InterfaceDemo1{
public static void main(String[]args){
//System.out.println(Shape.i=2);
}
}
 
//代表图形的类
//当抽象类里都是抽象方法时可以把类转成接口来表示
//接口本质不是类
//接口与接口之间支持多继承
interface Shape extends Cloneable,Serializable{
//属性，默认被publicfinalstatic共同修饰
public final static int i=1;
 
//抽象方法默认被Publicabstract默认修饰
public abstract double getGirth();
double getArea();
}
 
//代表矩形类---普通类
//implements---代表类与接口之间的实现关系
//实现类
//类与接口之间支持多实现
//实现类需要把接口里的所有抽象方法进行重写，如果不想都重写可以把实现类变成抽象类
abstract class Rectangle implements Shape,Cloneable{
/*@Override
publicdoublegetGirth(){
return0;
}*/
 
@Override
public double getArea(){
return 0;
}
}

2.抽象类与接口的区别

1.接口不是类
2.接口里只有抽象方法
3.类与接口支持多实现，接口与接口支持多继承
4.接口里属性和抽象方法有默认修饰符
5.抽象类有构造方法
6.抽象类为了延展类的继承结构，接口是为了注入更多的特性

3.接口优点
模板、约束

内部类

类/接口里定义类
类里定义类

方法内部类

在方法内定义类
可以定义所有的非静态信息以及静态常量
可以正常的继承和实现
不能被访问权限修饰符来修饰但是可以被abstract以及final来修饰
可以获取外部类所有的信息
只能获取当前方法的常量信息

public class InnerDemo1{
public static void main(String[]args){
//创建外部类对象调用方法执行创建内部类对象的语句
new Outer1().m();
}
}
//外部类
class Outer1{
//属性
static int k=1;
//方法
public void m(){
int y=1;//在jdk1.8以前定义常量需要手动加上final
//在jdk1.8及其以后定义变量时底层默认会添加final但是如果手动添加了
//底层就不再添加
 
//方法内部类
//定义所有非静态信息以及静态常量
//可以正常的继承与实现
//不能被访问权限修饰符来修饰但是可以被abstract以及final来修饰
//可以获取外部类所有的信息
//只能获取本方法的常量
class Inner1 extends Object implements Cloneable{
static final int x=1;
public void n(){
System.out.println(k);
System.out.println(y);
}
}
//创建方法内部类对象
Inner1 in1=new Inner1();
in1.n();
}
}

成员内部类

在成员位置定义类
可以定义所有的非静态信息以及静态常量
可以正常的继承和实现
可以被访问权限修饰符以及abstract和final来修饰
可以获取外部类所有的信息

Outer2.Inner2  inner2=new  Outer2().new  Inner2();

import java.util.Scanner;
 
public class InnerDemo2{
public static void main(String[]args){
//Outer2.Inner2表示内部类
//Outer2.Inner2inner2=newOuter2().in2;
//in2=newInner2();
Outer2.Inner2 inner2=new Outer2().newInner2();
 
}
}
//外部类
class Outer2{
//属性
static int k=1;
//非静态属性
//Inner2in2=newInner2();
 
//成员内部类
//可以定义所有的非静态信息以及静态常量
//可以正常的继承和实现
//可以让访问权限修饰符以及abstract和final来修饰
//可以获取外部类所有的信息
class Inner2 extends Object implements Cloneable{
static final int x=1;
public void n(){
System.out.println(k);
m();
}
}
//方法
publicvoidm(){}
}

静态内部类
成员内部类被static来修饰
可以定义所有信息
可以正常的继承和实现
可以被访问权限修饰符以及abstract和final来修饰
只能获取外部类的静态信息

Outer3.Inner3   inner3=new   Outer3.Inner3();

public class InnerDemo3{
public static void main(String[]args){
//创建静态内部类对象
Outer3.Inner3 inner3=new Outer3.Inner3();
 
}
}
//外部类
class Outer3{
//属性
static int k=1;
//
static Inner3 in3=new Inner3();
//静态内部类
//可以定义所有信息
//可以进行正常的继承和实现
//可以让访问权限修饰符以及abstract和final来修饰
//只能获取外部类静态信息
static class Inner3 extends Object implements Cloneable{
static final int x=1;
public void n(){
System.out.println(k);
}
}
//方法
public void m(){}
}

匿名内部类
用于继承类/实现接口，重写抽象方法
可以被继承的类/接口都可以拥有匿名内部类的形式
匿名内部类只能使用一次
当做参数传递时来使用

public class InnerDemo4{
public static void main(String[]args){
//创建抽象类子类对象
/*Dd=newD();
d.m();*/
 
//匿名内部类
//继承类，重写抽象方法，创建匿名内部类对象
//当类可以被继承/是接口时，拥有匿名内部类的形式
//只能使用一次
C c= new C(){
@Override
public void m(){
System.out.println(1);
}
};
c.m();
 
//普通类也具有匿名内部类的形式
B b=new B(){};
 
//接口也具有匿名内部类的形式
A a=new A(){
};
//调用方法
//匿名内部类当做参数使用
m(new A(){});
}
public static void m(Aa){//只能接收A接口的实现类对象
}
}
//接口
interface A{}
//普通类
class B{}
//抽象类
abstract class C{
public abstract void m();
}
class D extends C{
@Override
public void m(){
System.out.println(1);
}
}

接口里定义类/内部接口默认都是被static修饰

public class InnerDemo5{
public static void main(String[]args){
System.out.println(Outer5.Inner5.i);
System.out.println(Outer5.Inner6.j);
System.out.println(Outer5.Inner5.Inner7.x);
}
}
interface Outer5{
//接口里定义接口，默认被static修饰
static interface Inner6{
int j=1;
}
//接口里定义内部类默认被static修饰
static class Inner5{
static int i=1;
//类里定义接口,默认被static修饰
static interface Inner7{
int x=1;
}
}
}