15-内部类,比较器

15-内部类,比较器

• java中的内部类: 在一个类中定义另一个类叫做内部类,是一个独立的类,在编译的时候内部类会被编译成独立的.class文件
  • 例: 在A类中定义一个B类 —>> A$B.class
  • 根据内部定义的位置进行分类:
    • 成员内部类 -->成员变量
    • 局部内部类 -->局部变量
    • 静态内部类 -->静态变量
    • 匿名内部类

public class Test{
    public static void main(String[] args){
        
        //成员内部类创建对象
        Outer outer = new Outer();
        outer.new Inner();
        //成员内部类的创建方式
        Outer.Inner inn = new Outer().new Inner();
        
        //静态内部类创建
        StaticInn.Inner s = new StaticInn.Inner();
        
        //局部内部类
        PartInn p = new PartInn();
        p.method();
        
        //匿名创建对象
        new PartInn().method();	
    }
}

• 成员内部类:

  1. 成员内部类可以看做是一个成员变量, 位置: 外部类类中,方法体外

  2. 可以使用控制访问权限的修饰符修饰

  3. 成员内部类就可以访问外部类类中的所有数据

  4. 成员内部类不能拥有静态声明

  5. 成员内部类创建对象

     语法:

     ​ 外部类类名 外部类类名对象 = new 外部类();

     ​ 外部类类名对象.new 内部类类名();

     ​

     ​ 外部类类名.内部类类名 内部类对象名 = new 外部类类名().new 内部类类名();

public class Outer {  //外部类
	private String name;  //私有成员变量
	static String age;   //静态变量
	static void phoebe(){};
	public void m(){};
	
	
    class Inner{  //内部类  -->这个类被定义在成员变量的位置上,这个类有四种访问修饰
    	private  String name; 
		public void printt(){   //内部类中的方法
			System.out.println("name:"+name+age);  
			System.out.println("在内部类中访问外部类的私有属性:"+Outer.this.name);
			
			phoebe();
			m();
			
        }
	}
}

• 匿名内部类:
  • 匿名内部类的前提必须存在继承或实现的关系,创建接口或抽象类的对象(实现抽象类或接口的方法)
    • 没有类名
    • 好处: 少定义一个类
    • 缺点: 无法重复利用

public class AnonInner {
    
	public static void main(String[] args) {
		/*//创建aa对象
		aa a = new aa();
		a.logout();*/
		
		Cust c = new Cust() 
		{  //实现内容的开始
					@Override
					public void logout() {
							System.out.println("我最好看....");							
		}	
		};  //实现方法的结束
       c.logout();
	

}
interface Cust{   
	//退出登录
	void logout();   //抽象方法

}}
/*class aa implements Cust{

	@Override
	public void logout() {
			System.out.println("好的,我退出了....");
		
	}
}*/

• 静态内部类:
  1. 静态内部类可以看作是静态变量
  2. 可以被控制权限修饰符修饰
  3. 可以声明静态的和非静态的声明
  4. 可以直接访问外部类中的静态数据,但是不能直接访问成员变量

public class StaticInn {
     //静态变量
	static String str1;
	//成员变量
	String str2;
	//静态方法
	static void m1(){}
	//成员方法
	void m2(){}
	
	 static class Inner{   //静态内部类
		
		 public void sss(){
			 System.out.println(str1);
			 //System.out.println(str2);   //静态的内部类不能使用非静态的属性/方法
			  //m2();
			  m1();
		 }
	}
}

• 局部内部类:
  1. 局部内部可以看作是局部变量
  2. 局部内部类不可以用控制访问权限修饰符修饰
  3. 局部内部类不能有静态声明
  4. 局部内部类访问局部变量时,局部变量之前默认加final

public class PartInn {
	int a = 1;
	
	public void method(){  //成员方法
		class Inner{   //局部内部类
			final int i = 2;   // 
			
		   public void m1(){
			   System.out.println(a);
			   System.out.println(i);
		   }
			
		}
		Inner inn = new Inner();
	    inn.m1();
	}
	
	
}

• 比较器----汉字如何排序?

import java.text.CollationKey;
import java.text.Collator;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Locale;

/**
 * 
 * @author Administrator
 *
 */
public class Comp {
   public static void main(String[] args) {
	
	   String[] arr ={"a","o","b","g"};
	   Arrays.sort(arr);    //有序
	   System.out.println(Arrays.toString(arr));
	   
	   System.out.println("=========================");
	   String[] arra = {"张三","李四","王五","赵六"};
	  
	   Arrays.sort(arra,new Comparator<String>() {

		@Override
		public int compare(String o1, String o2) {   //设置语言环境
			Collator coll = 	Collator.getInstance(Locale.CHINA);   //获取静态方法,用于创建一个collator对象
			CollationKey s1 = coll.getCollationKey(o1);
			CollationKey s2 =coll.getCollationKey(o2);
			
			return s1.compareTo(s2);
		}
		
	});
	   System.out.println(Arrays.toString(arra));
}	
}