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;
}
}
}
