java内部类

内部类

定义在类中的类被称作为内部类

普通内部类

* 普通内部类
* a：外部类中如何使用内部类的属性以及方法
* 在外部类中创建内部类对象 调用内部类功能、属性
* b:内部类中使用外部类的属性以及方法
* 可以直接使用
* c:其它类中调用内部类中的属性和方法：
* 1:
* a：导包 包名.外部类.内部类
* b：内部类类型 变量名= new 外部类对象().new 内部类对象
* Inner01 in = new Outer01().new Inner01();
* 2:
* 外部类.内部类 变量名= new 外部类对象().new 内部类对象* Outer01.Inner01 in = new Outer01().new Inner01();
*

public class Test01 {
    public static void main(String[] args) {
    //创建外部类对象
    Outer01 out = new Outer01();
    out.method();
    // 创建inner对象
    Outer01.Inner01 in = new Outer01().new Inner01();
    int num = new Outer01().num;
    }
} 
class Outer01{
    int num;
    public Outer01(){
        
    } 
    public void method() {
    // 使用内部类中的属性
    	Inner01 in = new Inner01();
   	 	in.fun();
   	 	System.out.println("outer method");
    } 
    /* private */
    class Inner01 {
    	public Inner01() {
        
    	} 
    	public void fun() {
            /*
            * Outer01 out = new Outer01(); 			out.method();
            */
   		 	method();
   		 	System.out.println("Inner fun");
  	  	 }
    } 
    class Inner02{
    	public Inner02() {
    } 
    	public void fun1() {
   			//fun();
   			System.out.println("Inner fun");
   		}
    }
}

---

静态内部类

静态内部类：
* 通过static修饰的内部类称之为静态内部类
* a：外部类中如何使用静态内部类的属性以及方法
* 创建对象，调用对象的属性以及方法
* *
b:静态内部类中使用外部类的属性以及方法
* 创建外部类的对象 调用对象的属性以及方法
* *
c:其它类中调用内部类中的属性和方法：
* 1:
* a：导包 包名.外部类.内部类
* b：内部类类型 变量名= new 外部类. 内部类对象()
* Inner01 in = new Outer02.Inner01();
* 2:
* 外部类.内部类 变量名= new 外部类. 内部类对象()
* Outer01.Inner01 in =new Outer02.Inner01();	

publicclassTest02{
    publicstaticvoidmain(String[]args){
    	//创建对象
    	Inner01inner=newOuter02.Inner01();
    	inner.fun();
    }
}
classOuter02{
    intnum;
    publicOuter02(){
        
    }
    publicvoidmethod(){
    	newInner01().fun();
 		System.out.println("outer2method"+Inner01
                           .num);
    }
    staticclassInner01{
    	staticintnum=10;
    	publicInner01(){ 
    	}
        publicvoidfun(){
            //newOuter02().method();
            System.out.println("Innerfun");
        }
    }
    publicstaticvoidfun(){
    	newOuter02().method();
    }
}

---

局部内部类

/**
*局部内部类：
*定义在方法中的类只能当前方法使用
*一定程度减少内存开销但是复用性是及其低的
*@authorwawjy
*
*/
publicclassTest03{
    publicstaticvoidmain(String[]args){
        
    }
    publicstaticvoidinfo(){
    	classInner{
            
    	}
    }
}

---

匿名内部类

/**
*匿名内部类就是没有名字的内部类
*正因为没有名字所以一般都只是使用一次
*匿名内部类的前提是继承一个父类或者实现一个接口
*/

匿名内部类
*两种比较的接口：
*内部比较器
*java.lang.Compareable比较大小
*外部比较器
*java.util.Comparator
*/
publicclassTest01{
    publicstaticvoidmain(String[]args){
        //比较两个字符串的大小
        Stringstr1="d";//Stringchar[]value={'a','b','c','d'}
        Stringstr2="aaaaaa";//char[]value={'a','b','c','e'}
        //String中已经重写了comparTo方法所以可以直接进行比较
        if(str1.compareTo(str2)>0){
        	System.out.println(str1);
        }else if(str1.compareTo(str2)==0){
        	System.out.println("相等");
        }else{
        	System.out.println(str2);
        }
        //创建比较器对象
        MyComm=newMyCom();
        intnum=m.compare(str1,str2);
        if(num>0){
        	System.out.println(str1);
        }else if(num==0){
        	System.out.println("相等");
        }else{
        	System.out.println(str2);
        }
    }
}
classMyComimplementsComparator{
    @Override
    publicintcompare(Objecto1,Objecto2){
        Stringstr1=(String)o1;
        Stringstr2=(String)o2;
        returnstr1.length()-str2.length();
    }
}