java：面向对象（接口（续），Compareble重写，Comparator接口：比较器的重写，内部类，垃圾回收机制）

接口：

*接口定义:使用interface关键字
* [修饰符] interface 接口名 [extends 父接口1,父接口2...]{
* //常量的声明
* //方法的声明
* }
*接口成员的特点:
*1.接口中所有的成员变量是常量，默认修饰符为public static final
*2.接口中所有的方法都是抽象方法，默认修饰符为:public abstract
*3.接口不能实例化，接口不能构造方法(抽象类不能实例化，但可以有构造方法)
*4.java类是单继承，但接口可以是多继承
*5.一个非抽象类实现实现接口，必须重写接口中的抽象方法，抽象类实现接口可以重写部分抽象方法。
*6.一个类只能继承一个父类，但可以实现多个接口
*7.接口中被重写N次的方法，最后调用，调用的都是最后一次被重写的方法。
*如果一个类继承父类并实现了接口如何编写?
* [修饰符] class 类名 [extends 父类名 implements 接口名1,接口名2..]{
* }
* eg:
* public class E extends D implements A,B{
*
* }

public interface A {
    void m1();//public abstract void m();
}

public interface B {
    void m2();
}

public interface C extends A,B{
//    void m1();//从接口A继承而来
//    void m2(); //从接口B继承而来
    void m3();
}

public class D {
    public void test(){
        System.out.println("D类中的test方法.....");
    }
}

/**
 *因为抽象类中是可以存在抽象方法的，所以一个抽象类实现了接口，可以重写或不重新接口中的抽象方法。 
 *
 */
public abstract class F implements C{
//    public abstract void m1();
//    public abstract void m2();
//    public abstract void m3();
}

/**
 * 该类继承了父类D并实现了接口A和接口B
 * 必须实现(重写)接口A和接口B的抽象方法
 *
 */
public class E extends D implements A,B{

    @Override
    public void m2() {
        System.out.println("实现了接口B中的m2抽象方法");
    }

    @Override
    public void m1() {
        System.out.println("实现了接口A中m1抽象方法");
    }
    
    
    public static void main(String[] args) {
        E  e = new E();//类本身进行new
        e.m1();
        e.m2();
        e.test();
        System.out.println("-------------------------");
        D  e2 = new E();//用父类new子类,向上转型,只能访问父类中的test方法
        e2.test();
        System.out.println("-------------------------");
        A  e3 = new E();//利用接口A创建实现类,向上转型,只能访问接口A中定义的m1方法
        e3.m1();
        System.out.println("--------------------------");
        B  e4 = new E();//利用接口B创建实现类,只能访问接口A中定义的m2方法
        e4.m2();
        
    }

}

 

java.lang.Comparable接口:此接口强行对实现它的每个类的对象进行整体排序。
* 排序规则在compareTo()方法中定义。
* 当调用java.util.Arrays类中sort(Object[] objs)时，
* 程序会调用compareTo()方法对对象进行比较，
* 如果该方法返回正整数(1)时，代表当前对象大于待比较对象；
* 如果返回0，代表当前对象等于待比较对象
* 如果该方法返回负整数(-1)时，代表当前对象小于待比较对象；
*实现思路:
*1.实现Comparable接口，并重新其compareTo方法
*2.在compareTo方法中定义比较规则。返回值应该是正整数，零和负整数。
*3.在调用Arrays.sort(Object[] objs)方法的过程中，sort方法的内部对调用compareTo方法进行比较。

public class Student  {
    private String name;
    private int age;
    private int score;
    public Student(String name, int age, int score) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public Student() {
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
    }
    
    
}

public class TestArray {
    /*
     * 按照年龄进行排序,冒泡
     * N个数字来排队，两两比较小靠前，
     * 外层循环N-1(需要比较的轮数)
     * 内存循环N-1-i(每轮需要比较的次数)
     */
    public static void sort(Student[] stus){
        for(int i=0;i<stus.length-1;i++){
            for(int j=0;j<stus.length-1-i;j++){
                //先从学生对象中获取该学生的年龄
                if(stus[j].getAge()>stus[j+1].getAge()){
                    //交换位置
                    Student temp=stus[j];
                    stus[j]=stus[j+1];
                    stus[j+1]=temp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        Student[] stus = new Student[5];//保存学生信息的数组
        stus[0]=new Student("aa",20,80);
        stus[1]=new Student("bb",22,78);
        stus[2]=new Student("cc",18,90);
        stus[3]=new Student("dd",25,82);
        stus[4]=new Student("ee",24,81);
        System.out.println("排序前:");
        for (Student student : stus) {
            System.out.println(student);
        }
        sort(stus);//排序
        System.out.println("排序后:");
        for (Student student : stus) {
            System.out.println(student);
        }
    }
}

Comparable接口:

public class Student implements Comparable{
    private String name;
    private int age;
    private int score;
    public Student(String name, int age, int score) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public Student() {
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
    }
    /**
     * 制定比较规则:
     * compareTo(Object o):比较当前对象与指定对象o之间的关系。
     * 如果当前对象大于指定对象o返回值是正整数
     * 如果当前对象等于指定对象o返回值是零
     * 如果当前对象小于指定对象o返回值是负整数
     */
    @Override
    public int compareTo(Object o) {
        Student stu = (Student)o;
//        if(age>stu.getAge()){
//            return 1;
//        }else if(age==stu.getAge()){
//            return 0;
//        }else{
//            return -1;
//        }
        return (age-stu.getAge());
    }
    
    
}

import java.util.Arrays;
/**
 *java.util.Arrays类
 *sort(Object[] objs):根据元素的自然顺序对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Comparable接口 
 *
 */
public class TestArrays {
    public static void main(String[] args) {
        Student[] stus = new Student[5];//保存学生信息的数组
        stus[0]=new Student("aa",20,80);
        stus[1]=new Student("bb",22,78);
        stus[2]=new Student("cc",18,90);
        stus[3]=new Student("dd",25,82);
        stus[4]=new Student("ee",24,81);
        System.out.println("排序前:");
        for (Student student : stus) {
            System.out.println(student);
        }
        Arrays.sort(stus);
        System.out.println("排序后:");
        for (Student student : stus) {
            System.out.println(student);
        }

    }
}

 Comparator接口：比较器:

import java.util.Comparator;
/**
 * java.util.Comparator接口:比较器
 * int compare(Object o1, Object o2):比较用来排序的两个参数。
 *     根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
 * 
 */
public class ScoreComparator implements Comparator{
    
    /**
     * 定义比较规则:按照分数的降序进行排列
     */
    @Override
    public int compare(Object o1, Object o2) {
        Student stu1=null;
        Student stu2=null;
        if(o1 instanceof Student){
            stu1=(Student)o1;
        }
        if(o2 instanceof Student){
            stu2=(Student)o2;
        }
//        if(stu1.getScore()>stu2.getScore()){
//            return 1;
//        }else if(stu1.getScore()==stu2.getScore()){
//            return 0;
//        }else{
//            return -1;
//        }
        return -(stu1.getScore()-stu2.getScore());
    }

}

import java.util.Arrays;

import cn.zzsxt.oop4.Student;
/**
 * java.util.Arrays类
 * sort(Object[] objs,Comparator c):按照指定的比较器对指定数组进行排序。
 *
 */
public class TestArrays {
    public static void main(String[] args) {
        Student[] stus = new Student[5];//保存学生信息的数组
        stus[0]=new Student("aa",20,80);
        stus[1]=new Student("bb",22,78);
        stus[2]=new Student("cc",18,90);
        stus[3]=new Student("dd",25,82);
        stus[4]=new Student("ee",24,81);
        System.out.println("排序前:");
        for (Student student : stus) {
            System.out.println(student);
        }
        Arrays.sort(stus, new ScoreComparator());//利用指定的比较器完成比较
        System.out.println("排序后:");
        for (Student student : stus) {
            System.out.println(student);
        }
        
    }
}

*内部类:将一个类定义置入另一个类定义中就叫作“内部类”
*特点:
*1.内部类可以访问外部的成员，但外部类不能访问内部的成员。
*2.外部类的修饰符只有两种:public和默认，而内部类的修饰符可以是public,protected,默认,private
*3.内部类成员只有在内部类的范围之内是有效的。
*4.用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
*成员内部类:将一个类作为另外一个类的成员

*内部类的分类:成员内部类，静态内部类，方法内部类，匿名类。
*成员内部类:将一个类作为另外一个类的成员
*静态内部类:使用static修饰的内部类。静态内部只能访问外部的静态成员。

public class Outclass {//外部类
    private String name="name";
    private int num1=1;
    public void show1(){
        System.out.println("外部方法");
    }
     public class intclass{//内部类
        private int num1=2;
        public void show(){
            System.out.println("内部方法");
            System.out.println(num1);
            System.out.println(name);//访问外部类的不同名成员
            System.out.println(Outclass.this.num1);//访问外部类的同名成员
            show1();//访问外部类的方法
        }
    }
    public static void main(String[] args) {
        Outclass o=new Outclass();
        /*
         * 创建内部类的实例:
         * 外部类.内部类 对象名 = new 外部类().new 内部类();
         */
        Outclass.intclass i=new Outclass().new intclass();
        
//        i.show1();  不能调用外部类的成员和方法
        i.show();
    }
}

静态内部类：

/*
*静态内部类:使用static修饰的内部类。静态内部只能访问外部的静态成员。
 *
 */
//外部类
public class OuterClass2 {
    //外部类的成员
    private static String name="zhangsan";
    private static int num=10;
    //外部类的方法
    public void outerMethod(){
//        System.out.println(a);//外部类不能访问内部类的成员
    }
    //内部类
    public static class InnerClass{
        //内部类的成员
        private int num=20;
        private int a=30;
        //内部类的方法
        public void innerMethod(){
            System.out.println("OuterClass--->name="+name);//内部类可以访问外部类的成员
            System.out.println("OuterClass--->num="+OuterClass2.num);//外部类的成员
            System.out.println("InnerClass--->num="+this.num);//内部类的成员
        }
    }
    
    public static void main(String[] args) {
        /*
         * 创建静态内部类的实例:
         * 外部类.内部类 对象名 = new 外部类.内部类();
         */
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();
        innerClass.innerMethod();
        
    }
    
}

方法内部类：

1.在方法中定义的内部类。

2.如果该内部类需要访问方法中局部变量，该局部变量前必须加final。

3.方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

//外部类  
public class HelloWorld {  
      
    private String name = "考试课程";  
      
    // 外部类中的show方法  
    public void show() {   
        // 定义方法内部类  
        class MInner {  
            int score = 78;  
            public int getScore() {  
                return score + 10;  
            }  
        }  
          
        // 创建方法内部类的对象  
        MInner mi = new MInner();  
          
        // 调用内部类的方法  
        int newScore = mi.getScore();  
          
        System.out.println("姓名：" + name + "
加分后的成绩：" + newScore);  
    }  
      
    // 测试方法内部类  
    public static void main(String[] args) {  
          
        // 创建外部类的对象  
          
        HelloWorld mo = new HelloWorld();  
        // 调用外部类的方法  
        mo.show();  
    }  
}  

匿名内部类：

/**
 * 匿名内部类:没有名称的内部类
 * 匿名内部类可以实现一个接口或继承一个父类.
 */
public class TestAnonymous {
    public static void main(String[] args) {
        //实现一个接口的匿名内部类
        /*
         *  class MyClass implements MyInterface{
         *      public void test(){
         *          ..
         *      }
         *  }
         *  MyClass myClass = new MyClass();
         *  myClass.test();
         */
        new MyInterface() {
            public void test() {
                System.out.println("测试匿名内部的test方法....");
            }
        }.test();
        /*
         * 继承的匿名类。
         * class MyThread extends Thread{
         *      public void run(){
         *      .... 
         *   }
         * }
         * MyThread myThread = new MyThread();
         * myThread.start();
         */
        new Thread(){
            public void run() {
                System.out.println("Thread....run方法...");
            }
        }.start();
    }
}

* GC:

　　垃圾回收机制，有虚拟机自动调用，程序员无法精确控制。

　　其开销影响性能，java虚拟机必须跟踪程序中有用的对象，确定哪些无用的。

　　只回收JVM堆内存里的对象空间

* GC机制的优点:
　　* 1.提高编程效率,摈弃了C/C++中的指针，避免因遗忘释放内存而导致的内存泄漏。
　　* 2.保证了程序的完整性。

* GC原理:

　　JVM中有一个线程专门用于回收堆内存中不使用对象，常用的方法:
　　　　* 1.定时扫描堆中不使用的对象
　　　　* 2.通过计数控制回收时机。

* 什么数据会被垃圾回收？
　　* 垃圾回收机制回收的堆内存中的对象信息，不能回收物理连接，数据库连接，输入/输出和Socket。
　　* 当对象不再使用时推荐将该对象的引用更改null,暗示 垃圾回收器优先处理。

* 建议虚拟机进行垃圾回收的方法：

　　可以设置为null，暗示GC回收

　　System.gc()或Runtime.getRunTime().gc();

 finalize（）在垃圾回收前调用，可以在该方法中编写一些垃圾回收前想做事情的代码。

不建议程序员手工调用，该方法是由JVM自动调用GC

 

public class Student {
    String name;
    public Student(String name){
        this.name=name;
    }
    /**
     * finalize()在垃圾回收前调用，可以在该方法中编写一些垃圾回收前要做的事情的代码
     * 不建议程序员手工调用，该方法是有JVM在垃圾回收前自动调用
     */
    @Override
    protected void finalize() throws Throwable {
        System.out.println("finalize()被调用了");
    }
    
    
}

public class TestGc {
    public static void main(String[] args) {
        Student stu = new Student("张三");
        System.out.println(stu);
        stu=null;
        //建议垃圾回收器回收垃圾
        System.gc();
    }
}