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;

		}

	}

}

巴特西

JAVA高级特性--内部类

最新文章

热门文章