*接口: 使用interface关键字进行定义,接口是一种规范,接口中的方法都是抽象方法,
* 其实现类中必须重写接口中的抽象方法
*
常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract.
*public interface 接口名{
*}
*接口中的所有的方法都是抽象方法,默认使用public abstract修饰
*void fly(); ===>public abstract void fly();
*接口中所有变量为常量，默认使用public static final修饰
*double PI=3.14;===>public static final double PI=3.14;
*接口没有构造函数，接口不能实例化
*
*一个类实现接口使用implements关键字
* 一旦一个类实现了接口,就必须将接口中抽象方法进行重新
* java中的继承为单继承,但java中一个类可以实现多个接口(必须将所实现的接口中的抽象方法全部 s重写)
* class 类名 extends 父类 implemnts 接口1,接口2....{
* }
public class Test {
public static void main(String[] args) {
Volant volant = new Angel();
volant.fly();
System.out.println(Volant.FLY_HIGHT);
}
}
interface Volant {
int FLY_HIGHT = 100; // 总是：public static final
void fly(); //总是：public abstract void fly2();
}
interface Honest {
void helpOther();
}
class Angel implements Volant, Honest{
public void fly() {
System.out.println("我是天使，飞起来啦！");
}
public void helpOther() {
System.out.println("扶老奶奶过马路！");
}
}
class GoodMan implements Honest {
public void helpOther() {
System.out.println("扶老奶奶过马路！");
}
}
class BirdMan implements Volant {
public void fly() {
System.out.println("我是鸟人，正在飞！");
}
}
class Bird implements Volant {
public void fly() {
System.out.println("正在飞！");
}
}
class Plane implements Volant {
public void fly() {
System.out.println("正在飞！");
}
}
class Satellite implements Volant {
public void fly() {
System.out.println("正在飞！");
}
}
class Missile implements Volant {
public void fly() {
System.out.println("正在飞！");
}
}
abstract(抽象)修饰符必须放在类名前
1 abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。
2 abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以"；"代替。需要子类继承实现（覆盖）。
3 有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。
4 父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。
*问题:
*1.通过方法的重载解决：每增加一种类型，都必须添加一个 testFly的重载方法
*
*继承代表了一种is-a关系
*接口代表了一种has-a关系
*利用多态来解决：同一种"接口"因不同的实现而执行不同的操作
*1.利用多态+继承+方法的重写来解决(有一个合适的父类)
*2.利用多态+接口+方法的重写来解决()
* 接口和类一样可以被继承:extends
*抽象类也是可以实现接口
* Java中的类的继承是单继承,但接口可以多继承
/**
* 问题1 :sort(int[] nums):只能针对int类型的数组进行排 序,byte,short,long,float,char,double?
* 解决:可以通过方法的重载来解决 sort(double[] nums),需要8个这样的方法
* 问题2:Student(name,age,score):按照学生的成绩排序?
* sort(Student[] stu),sort(Employee[] stu):
* java中引用类型(接口，类，数组)太多
* sort(Object[] obj)
* 数值类型的比较:>,>=,<,<=,==,!=
* 引用类型:stu1>stu2 错误
*冒泡排序:
N个数字来排队,两两比较小靠前
外层循环N-1(控制比较轮数),内存循环N-1-i(控制每轮比较的次数)
*java.lang.Comparable:此接口强行对实现它的每个类的对象进行整体排序
*需要重写compareTo(目标对象)方法:
* 如果当前对象>目标对象,返回值为正整数(1)
* 如果当前对象=目标对象 ,返回值为零(0)
* 如果当前对象<目标对象 ,返回值为负整数(-1)
*内部类:在一个类中嵌套的类。
*内部类可以之间访问外部类的成员变量(包括private修饰的),外部类不能直接访问内部类的 成员变量
*外部类的修饰符:public和默认，内部类的修饰符可以有四个(public,protected,默 认,private)
*编译后生成的字节码文件:OuterClass.class,OuterClass$InnerClass.class
*内部类成员只有在内部类的范围之内是有效的
*内部内的分类:
成员内部类***
静态内部类:只能访问外部类中静态的属性
方法内部类:在方法中定义的内部类 *
*注意:在方法内部中如果访问外部类的局部变量，该局部变量必须使用final修饰
*匿名内部类:没有名字的内部类
*使用场景:当类的对象只使用一次时候，可以考虑使用匿名内部类(android,图形化界面),可 以通过匿名内部类简化代码
*可以实现一个接口，或者继承一个父类
*匿名内部类如果访问外部类的局部变量，该局部变量必须使用final修饰
*实现一个接口的匿名类
*java中的垃圾回收：回收是堆内存new出来的对象，程序员无法精准控制回收时机
*可以通过System.gc()或Runtime.getRuntime().gc();建议JVM进行垃圾回收
*JVM垃圾回收时会调用finalize()方法.
*垃圾回收的优点:
*1.程序员无需显示释放内存，提高开发效率
*2.可以保持程序的完整性
finalize()方法:属于Object类中的方法，当垃圾回收时调用，不建议程序员直接调用
来源：https://www.cnblogs.com/seePoppy/p/6710748.html