JAVA基础:内部类，匿名内部类，对象大小比较，Box容器迭代器封装实现

1 内部类

1.1 内部类编写

• 内部类就是内部的一个类

• 在什么内部呢？

  • 类的内部 ， 相当于类的一个特殊成员，具备类成员的访问特点 ，称为：成员内部类

    4种访问权限

    可以使用static关键字修饰

  • 方法的内部：类似于方法中的一个变量，称为：局部内部类

    只能在当前方法中使用

package com.a ;
class A{
    
    public static class B{} //内部类
    
    public void t1(){
        class B{} //内部类
    }
    
    public void t2(){
        new B()
    }
    
}

class B{
    private int i ;
    public void t1(){}
}

package com.b ;
public class B{}

1.2 内部类特点

特点1： 可用范围不同

特点2： 内部类可以直接使用外层类的成员（包括私有成员）

特点3： 局部内部类可以使用方法中的局部变量，但这个局部变量必须是final修饰的常量

• jdk1.7之前，要求局部变量必须用final关键字修饰

• jdk1.7之后，局部变量可以不使用final修饰，但必须不能改变。

class A{
    private int i = 10 ;
    class C{
        public void t1(){
            System.out.println(i);
        }
    }
}

class B{
    public void t1(){
        A a = new A();
        System.out.println(a.i); //错误
    }
}

class A{  
    public void t1(){
        final int i = 10 ;
        
        System.out.println(i);
        
        System.out.println(i);
        
        class B{
            public void t2(int j){
                //i = j ;  报错
                System.out.println(i)
            }
        }
    }
}

扩展

成员内部类的属性与外部类的属性同名时的调用

class A{
    int i = 10 ;
    class B{
        int i = 20 ;
        public void t1(){
            System.out.println(i); //B.i
            System.out.println(A.this.i); //A.i
        }
    }
}

1.3 使用内部类

• 使用内部类定义变量

class A{
    class B{}
}

main(){
    A.B b ;
}

 使用内部类创建对象

class A{
    int i ;
    static int j ;
    class B1{}
    static class B2{}
}


main(){
    new A().i = 10 ;
    A.j = 20 ;
    
    A a = new A();
    A.B1 b1 = new A().new B1();
    A.B2 b2 = new A.B2() ;
    
   
    a.i ;
    a.t1();
    b1.i ;
    b1.t1();
}

注意：

• 内部类的对象一旦创建，基于内部类特点无关了

• 与所有对象的使用都相同。

1.4 匿名内部类

• 只能在定义类的同时就使用 ，使用其创建对象

• 一般会配合接口和抽象类使用，表示定义一个接口或抽象类的子类，并直接使用其创建对象

interface A{
    void t1();
}
/*
class B implements A{
	int i  ;
	String name ;
    public void t1(){}
}
*/

main(){
   // A a = new B();
    A a = new A(){
         int i ;
         String name ;
         public void t1(){}
    };
    
    //代码至此，就是对a对象的操作
}

2 对象大小比较

• 基本数据类型可以使用> < ==完成大小比较

• 引用类型jdk也提供了大小比较规则（接口），提供了两种比较规则

2.1 对象自身比较

• 我让张三和李四比。 最终这个比较的动作是谁做的？ 张三做的 ， 张三本身就是比较重的一方

• 定义类时，实现Comparable接口，表示当前类对象自身就可以跟其他相同类型的对象进行大小比较

class Car implements Comparable{
    String name ;
    int price ;
    
    public int compareTo(Object other){
        //this ===> car1
        //other ====> car2
        Car car2 = (Car)other ;
        
        //准备this.price 和 other.price
        //返回<0表示 this < other   car1 < car2
        //返回 0表示 this == other car1 == car2
        //返回>0表示 this > other   car1 > car2
        
    }
}

main(){
    Car car1 = new Car("bmw",30w);
    Car car2 = new Car("benz",40w);
    car1.compareTo(car2) ;
}

2.2 第三方比较器比较

• 我让张三比较一下李四和王五，这个比较的动作是谁做的？张三，比较的双方 李四和王五

• 自定义第三方比较器，实现Comparator接口，重写compare方法

public class CarPriceComparator implements Comparator{
    public int compare(Object o1 , Object o2){
        Car car1 = (Car)o1 ;
        Car car2 = (Car)o2 ;
        return car1.price - car2.price ;
    }
}

main(){
    Car car1 = new Car("bmw",30w);
    Car car2 = new Car("benz",40w);
    Comparator c = CarPriceComparator(); 
    c.compareTo(car1,car2) ;
}

匿名内部类实现

 public Car maxByCount(Car car1 , Car car2){
     Comparator c = new Comparator() {
         @Override
         public int compare(Object o1, Object o2) {
             Car car1 = (Car)o1 ;
             Car car2 = (Car)o2 ;
             return car1.count - car2.count;
         }
     } ;
     int r = c.compare(car1,car2);
     ....
 }

 public Car maxByPrice(Car car1 , Car car2){
     Comparator c = new Comparator() {
         @Override
         public int compare(Object o1, Object o2) {
             Car car1 = (Car)o1 ;
             Car car2 = (Car)o2 ;
             return car1.price - car2.price;
         }
     } ;
     int r = c.compare(car1,car2);
     ....
 }