JAVA高级特性--内部类

内部类概念

public  class Outer{

     class  inner{

     }

}

　特点

　　　　可以很好的实现隐藏,可以使用procted,private

　　　可以直接访问外部类的所有成员 ,包括私有成员.

　　　　外部内不能访问内部类的成员,必须首先建立内部类的 对象才可访问

成员内部内及应用

//外部内不能访问内部内属性和方法,必须创建对象

//内部类中不能有静态方法和属性
//内部类可以访问Outer.this.name外部内属性
//静态常量在内部类中是可以的

package com.tanlei.newer;

public class MemberInner {
	public static void main(String[] args) {
         //创建外部内对象
		Outer outer=new Outer();
		outer.show();
		//创建内部类对象
		Outer.Inner inner=outer.new Inner();
		inner.show();
	}

}

class Outer {
	private String name = "tanle";
	private int num = 10;

	public void show() {
		System.out.println(name + num);
		//外部内不能访问内部内属性和方法,必须创建对象
		Inner inner1 =new Inner();
		inner1.show();
	}

	public class Inner {
		private String name = "lisi";
		private int num = 20;

		public void show() {
			//内部类中不能有静态方法和属性
			//内部类可以访问Outer.this.name外部内属性
			//静态常量在内部类中是可以的
			System.out.println(Outer.this.name +"    内部类"+ num);
		}
	}
}　 　

静态内部类

特点:

　　使用static修饰的成员内部类叫做静态内部类

　　外部类名.内部类名  实例名=new 外部类名.内部类名(参数).

限制

　　静态内部类不能与外部类重名

　　不能访问外部类的非静态的属性和方法,外部类不能访问内部类的非静态 的属性和方法

匿名内部类

特点

　　没有名称的内部类,没办法引用他们,必须在创建时作为new语句的一部分来声明并创建他们的实例

　　必须继承一个类或者实现一个接口

语法

　new interface接口的实现类/superclass子类(){

　　　　//类体
　　}

　　

package com.pojo;

public class Anoon {
	  public static void main(String[] args) {
		 Person person=new  Person();
		 /*Anamill dog=new DOGG();*/
		 person.feed(new Anamill() {

			@Override
			public void eat() {
				// TODO Auto-generated method stub
				System.out.println();
			}
		} );
	}
	}

	abstract class Anamill{
		public abstract void eat();
	}
	/*class DOGG extends Anamill{

		@Override
		public void eat() {
			System.out.println("啃骨头");

		}

	}*/
	class Person{
		public  void  feed(Anamill anamill) {
			anamill.eat();
		}
	}

　局部内部类

　　特点

　　　　定义在代码块,方法体类的

　局部内部类不能加访问修饰符

package com.pojo;

public class localInner {
  public static void main(String[] args) {
	Outer3 outer3=new Outer3();
	outer3.showOuter();
}
}
class Outer3{
	private String name="zhangs";
	private int agw =20;
	private static  int num=20;
	public void  showOuter() {
		final int mun44=50;//局部内部类只能访问声明其方法的常量

		class Inner3{
			private  int mun3=30;
			private  int num4=40;
			public  void  showInner() {
				System.out.println(mun3);
				System.out.println(num4);
				System.out.println(Outer3.this.name);
				System.out.println(Outer3.num);
				System.out.println(mun44);
			}
		}
		Inner3 inner3=new Inner3();
		inner3.showInner();
	}
}

　　

案例

package com.pojo;

import java.util.Arrays;

import com.pojo.Arraydemao.Entty;

public class Conter {
public static void main(String[] args) {
	  Arraydemao arraydemao=new Arraydemao();
	  arraydemao.put("1", "a");
	  arraydemao.put("2", "b");
	  arraydemao.put("3", "c");
	  arraydemao.put("4", "d");
	  arraydemao.put("5", "e");
	  Arraydemao.Entty [] entties1=arraydemao.getentties();
	   for (int i = 0; i < entties1.length; i++) {
		Entty entty=entties1[i];
		System.out.println(entty.getKey());
		System.out.println(entty.getValue());
	}
}
}

class Arraydemao{
	//存放entry对象的数组,默认大小为5
	private Entty[] entties=new Entty[5];
	private int count=0;//下标

	//对外提供的一个接口向容器中存放封装好的数据
	public  void put(String key,String value) {
		Entty entry=new Entty();
		entry.setKey(key);
		entry.setValue(value);
		entties[count++]=entry;//存放Entry对象到数组中

		//数组扩容
		if (count>=entties.length) {
			System.out.println("容器满了");
			//扩容后的新数组的大小
			int newCapacity=entties.length*2;
			//把老数组中的数据复制到长度为newCapacity薪数组中
			entties=Arrays.copyOf(entties,newCapacity);

		}
	}

	//把容器中的有数据内容返回
	public Entty[] getentties() {
		return Arrays.copyOfRange(entties, 0, count);

	}

	//把键值对封装在Entry对象中
	public static class Entty{
		private String key;
		private String value;
		public String getKey() {
			return key;
		}
		public void setKey(String key) {
			this.key = key;
		}
		public String getValue() {
			return value;
		}
		public void setValue(String value) {
			this.value = value;
		}

	}
}