内部类
从外部类的非静态方法之外的任意位置创建某个内部类的对象,都需要以外部类.内部类的格式指明对象类型
内部类拥有外围类的所有元素的访问权
外围类对象创建一个内部类对象时,此内部类对象会秘密地捕获一个指向那个外围类对象的引用。
在外围类静态方法中创建内部类对象源码如下:
public class InnerClass {
class InnerClass1{
public InnerClass1() {
int i1=1;
System.out.println("InnerClass1");
}
public void f1() {
System.out.println("InnerClass1_f1");
}
}
class InnerClass2{
int i2=2;
public InnerClass2() {
System.out.println("InnerClass2");
}
public void f2() {
System.out.println("InnerClass2_f2");
}
}
public InnerClass1 getInnerClass1() {
return new InnerClass1();
}
public static final void main(String...args) {
InnerClass ic=new InnerClass();
InnerClass.InnerClass1 i1=ic.getInnerClass1();
i1.f1();
InnerClass.InnerClass2 i2=ic.new InnerClass2();
i2.f2();
}
}
InnerClass1
InnerClass1_f1
InnerClass2
InnerClass2_f2
匿名内部类
匿名类版:
new NoNameClass(){
public void f3() {
System.out.println("f3");
}
}
完整版:
interface INoNameClass{
public void f3();
}
class NoNameClass implements INoNameClass{
public void f3() {
System.out.println("f3");
}
}
public static final void main(String...args) {
InnerClass ic=new InnerClass();
INoNameClass innc=ic.new NoNameClass();
}
注意:
abstract class NoNameClass2{
public NoNameClass2(int i){
System.out.println("构造器:"+i);
}
public abstract void f2();
//{System.out.println("{ }");}
}
public static final void main(String...args) {
InnerClass ic=new InnerClass();
ic.new NoNameClass2(53){
{System.out.println("{ }");}
public void f2() {
System.out.println("f2");
}
};
}
构造器:53
{ }
abstract class NoNameClass2{
public NoNameClass2(int i){
System.out.println("构造器:"+i);
}
public abstract void f2();
//{System.out.println("{ }");}
}
public static final void main(String...args) {
InnerClass ic=new InnerClass();
ic.new NoNameClass2(53){
{System.out.println("{ }");}
public void f2() {
System.out.println("f2");
}
};
}
{ }
构造器:53
匿名内部类若想要访问外部对象,则该对象需要加final
引用为什么匿名内部类只能访问其所在方法中的final类型的局部变量?中的一段话:
匿名内部类不能访问外部类方法中的局部变量,除非该变量被声明为final类型
1. 这里所说的“匿名内部类”主要是指在其外部类的成员方法内定义的同时完成实例化的类,若其访问该成员方法中的局部变量,局部变量必须要被final修饰。原因是编译器实现上的困难:内部类对象的生命周期很有可能会超过局部变量的生命周期。
2. 局部变量的生命周期:当该方法被调用时,该方法中的局部变量在栈中被创建,当方法调用结束时,退栈,这些局部变量全部死亡。而内部类对象生命周期与其它类对象一样:自创建一个匿名内部类对象,系统为该对象分配内存,直到没有引用变量指向分配给该对象的内存,它才有可能会死亡(被JVM垃圾回收)。所以完全可能出现的一种情况是:成员方法已调用结束,局部变量已死亡,但匿名内部类的对象仍然活着。
3. 如果匿名内部类的对象访问了同一个方法中的局部变量,就要求只要匿名内部类对象还活着,那么栈中的那些它要所访问的局部变量就不能“死亡”。
4. 解决方法:匿名内部类对象可以访问同一个方法中被定义为final类型的局部变量。定义为final后,编译器会把匿名内部类对象要访问的所有final类型局部变量,都拷贝一份作为该对象的成员变量。这样,即使栈中局部变量已经死亡,匿名内部类对象照样可以拿到该局部变量的值,因为它自己拷贝了一份,且与原局部变量的值始终保持一致(final类型不可变)。
只有该局部变量为不可变时,即为final时才能保证数据的可靠性。
嵌套类
普通内部类不能包含静态字段和方法,而嵌套类可以
嵌套类与static字段和方法都是一编译便存在,并且内存地址不再变化,直到gc回收。
接口内部的类
public class Staticer implements IStaticer{
@Override
public void fun() {
}
public static final void main(String...args) {
IStaticer is=new Staticer();
is.fun();
}
}
IStaticer_fun
内部类的作用
当存在抽象类时实现多重继承
public class Multipler extends Multipler1{
private AMultipler newClass() {
return new AMultipler(){
@Override
public void f1() {
System.out.println("AMultipler_f1");
}
};
}
public static final void main(String[] args) {
Multipler m=new Multipler();
m.f2();
AMultipler am=m.newClass();
am.f1();
}
}
class Multipler1{
public void f2() {
System.out.println("Multipler_f2");
}
}
abstract class AMultipler{
public abstract void f1();
}
Multipler_f2
AMultipler_f1
控制框架是一类特殊的应用程序框架,用来解决响应事件的需求
主要用来响应事件的系统被称做事件驱动系统
回调
类A调用类B的方法b,然后类B的方法b调用类A的方法a
interface ICallBacker{
public void fun();
}
class CallBacker2 implements ICallBacker{
@Override
public void fun() {
System.out.println("CallBacker2_ICallBackers_fun");
}
}
class CallBacker1{
public void fun() {
System.out.println("CallBacker1_fun");
}
private class InnerClass implements ICallBacker{
public void fun() {
System.out.println("CallBacker1_ICallBackers_fun");
CallBacker1.this.fun();
}
}
public InnerClass getInnerClass(CallBacker1 cb) {
return cb.new InnerClass();
}
}
public class CallBacker{
public static final void main(String...args) {
CallBacker1 cb1=new CallBacker1();
ICallBacker ic1=cb1.getInnerClass(cb1);
ic1.fun();
ICallBacker ic2=new CallBacker2();
ic2.fun();
}
}
CallBacker1_ICallBackers_fun
CallBacker1_fun
CallBacker2_ICallBackers_fun
在内部类InnerClass的fun方法中提供了一个CallBacker1钩子进行回调。
内部类的继承
由于内部类含有指向外围类的引用,应以以下方式使用继承
public class InnerExtend extends InnerExtend1.InnerExtend2{
public InnerExtend(InnerExtend1 ie1) {
//super();
ie1.super();
}
public static final void main(String...args) {
InnerExtend1 ie1=new InnerExtend1();
InnerExtend ie=new InnerExtend(ie1);
}
}
class InnerExtend1{
public InnerExtend1() {
System.out.println("InnerExtend1");
}
class InnerExtend2{
public InnerExtend2() {
System.out.println("InnerExtend2");
}
}
}
InnerExtend1
InnerExtend2
若将ie1.super()改成super()会报以下错误:
No enclosing instance of type InnerExtend1 is available due to some intermediate constructor invocation
容器
注意:List接口位于java.util包中,而在java.awt 包中也有一个List类
Set:只有元素不存在才会添加
TreeSet:按照值大小的顺序进行排序
LinkedHashSet:按照添加的顺序进行排序
HashSet:无序散乱地分布
List:不考虑重复,会按照添加顺序进行排序
容器选择:
要进行大量的随机访问:ArrayList
要从表中间插入或删除元素:LinkedList
各种Queue队列以及栈的行为,可由LinkedList构建
注意:
不应该适用vector,Hashtable和stack等过时的类
public static final void main(String...args) {
Vector v=new Vector();
System.out.print("showSet: ");
v.showSet();
System.out.println();
System.out.print("showList: ");
v.showList();
}
private void showList() {
Collection<Integer> cl=new ArrayList<Integer>();
Collection<Integer> cls=new ArrayList<Integer>();
cls.addAll(Arrays.<Integer>asList(1,2,3,4,5));
Collections.addAll(cls, 6,7,8,9,10);
cl.add(1);
cl.add(1);
cl.add(2);
cl.add(3);
cl.add(8);
cl.add(5);
for(Integer i:cl) {
System.out.print(i+" ");
}
System.out.print("|");
for(Integer i:cls) {
System.out.print(i+" ");
}
}
private void showSet() {
Collection<Integer> cl=new LinkedHashSet<Integer>();
Collection<Integer> clt=new TreeSet<Integer>();
cl.add(1);
cl.add(1);
cl.add(2);
cl.add(3);
cl.add(8);
cl.add(5);
clt.addAll(Arrays.asList(1,7,3,6,3));
for(Integer i:cl) {
System.out.print(i+" ");
}
System.out.print("|");
for(Integer i:clt) {
System.out.print(i+" ");
}
}
showSet: 1 2 3 8 5 |1 3 6 7
showList: 1 1 2 3 8 5 |1 2 3 4 5 6 7 8 9 10
在后续会探究各集合之间的算法实现和性能区别
注:点线框表示接口,实线框表示类,空心箭头的点线表示类实现了接口,实心箭头表示某个类可以生产箭头所指向类的对象。
迭代器
迭代器为轻量级对象也属于一种设计模式
不必为数量和类型操心:
private void showIterator() {
List<Integer> l=new ArrayList<Integer>();
for(int i=0;i<5;i++) {
l.add(i);
}
Iterator<Integer> i=l.iterator();
Set<Integer> s=new HashSet<Integer>();
for(int j=0;j<5;j++) {
s.add(j);
}
display(s.iterator());
display(l.iterator());
i=l.iterator();
while(i.hasNext()) {
i.next();
i.remove();
}
System.out.println(l.toString());
}
private void display(Iterator i) {
while(i.hasNext()) {
System.out.print(i.next()+" ");
}
System.out.print("\n");
}
0 1 2 3 4
0 1 2 3 4
[]
注意:迭代器对象要先调用一次next才是list容器中的第一个数据
ListIterator
一种只适用于List容器可双向遍历的迭代器
栈(叠加栈)
一个后进先出(LIFO)容器
用LinkedList实现栈存储:
public class Stacker {
public static final void main(String...args) {
String str="";
MyStack ms=new MyStack();
List<String> l=new ArrayList<String>(Arrays.asList("+","U","+","n","+","x","-","-"));;
System.out.println(l.toString());
Iterator i=l.iterator();
while(i.hasNext()) {
str=(String) i.next();
if(str.equals("+")) {
ms.push(i.next());
}
else if(str.equals("-")) {
ms.pop();
}
}
System.out.println(ms.toString());
}
}
class MyStack<T>{
public MyStack() {
}
LinkedList<T> stack=new LinkedList<T>();
public void push(T t) {
stack.add(t);
}
public T pop() {
//先进后出特性
return stack.removeLast();
}
public boolean isEmpty() {
return stack.isEmpty();
}
public String toString() {
return stack.toString();
}
}
[+, U, +, n, +, x, -, -]
[x]
队列
一个典型的先进先出(FIFO)的容器
LinkedList向上转型为Queue实现队列
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
public class Queuer {
static void printer(Queue q) {
while(q.peek()!=null) {
//先进先出特性
System.out.print(q.remove()+" ");
}
System.out.println();
}
public static final void main(String...args) {
Random rand=new Random(53);
Queue q=new LinkedList<Integer>();
int r=0;
for(int i=0;i<10;i++) {
r=rand.nextInt(20);
q.offer(r);
System.out.print(r+" ");
}
System.out.println();
printer(q);
}
}
16 7 16 1 8 15 12 2 10 0
16 7 16 1 8 15 12 2 10 0
PriorityQueue的使用
PriorityQueue
该类可以设置队列元素中的优先级
import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
public class Queuer {
public static final void main(String...args) {
comparatorer();
}
private static void comparatorer() {
Comparator<Oer> comparator=new Comparator<Oer>() {
@Override
public int compare(Oer o1, Oer o2) {
// TODO Auto-generated method stub
if(o1.getPriority()>o2.getPriority()) {
//o2
return -1;
}
else if(o2.getPriority()>o1.getPriority()) {
//o1
return 1;
}
return 0;
}
};
Oer o1=new Oer("o1",4);
Oer o2=new Oer("o2",53);
PriorityQueue<Oer> pq=new PriorityQueue<Oer>(2,comparator);
pq.offer(o1);
pq.offer(o2);
System.out.println(pq.toString());
}
}
class Oer{
private int priority;
private String name;
public Oer(String name,int priority) {
this.priority=priority;
this.name=name;
}
@Override
public String toString(){
return name;
}
public int getPriority() {
return priority;
}
}
[o2, o1]
通过继承AbstractCollection重写迭代类
import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class Collectioner {
public static final void main(String...args) {
List<Integer> list=new ArrayList<Integer>();
list.addAll(Arrays.asList(1,2,3,4,5));
Collectioner_child cc=new Collectioner_child(list);
Iterator<Integer> i=cc.iterator();
System.out.println(i.next());
}
}
class Collectioner_child extends AbstractCollection{
List<Integer> list;
public Collectioner_child(List<Integer> list) {
this.list=list;
}
@Override
public Iterator iterator() {
// TODO Auto-generated method stub
return new Iterator() {
private int index;
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
return index < list.size();
}
@Override
public Object next() {
// TODO Auto-generated method stub
return list.get(index++);
}
};
}
@Override
public int size() {
// TODO Auto-generated method stub
return list.size();
}
}
1
如果直接继承Collection接口需要实现大量的方法,而继承实现过Collection方法的AbstrctCollection抽象类只需要再实现两个抽象方法即可
通过该实例可进一步理解迭代器的使用。
自定义foreach规则
第一种(新建一个继承于ArrayList的自定义迭代器类)
import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class Iteratorer {
public Iteratorer() {
}
public static final void main(String...args) {
List<String> list=new ArrayList<String>(Arrays.asList("12","33","22"));
MyIterator<String> mi=new MyIterator<String>(list);
for(String i:mi) {
System.out.print(i+" ");
}
System.out.print("\n");
for(String i:mi.reversed()) {
System.out.print(i+" ");
}
System.out.println();
//java 8中的迭代循环
mi.reversed().forEach(System.out::print);
}
}
class MyIterator<T> extends ArrayList<T>{
public MyIterator(List<T> list) {
super(list);
}
public Iterable<T> reversed() {
return new Iterable<T>() {
@Override
public Iterator<T> iterator() {
// TODO Auto-generated method stub
return new Iterator<T>() {
int current=size()-1;
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
return current>-1;
}
@Override
public T next() {
// TODO Auto-generated method stub
return get(current--);
}
};
}
};
}
}
12 33 22
22 33 12
223312
第二种(直接在主类实现Iterator和Iterable接口)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class Iterator2 implements Iterator<String>,Iterable<String>{
private List<String> list;
private int size;
public static final void main(String...ags) {
Iterator2 i2=new Iterator2();
i2.list=new ArrayList<String>();
i2.list.addAll(Arrays.asList("a","v","c","d"));
i2.size=i2.list.size();
for(String s:i2) {
System.out.print(s+" ");
}
}
@Override
public Iterator<String> iterator() {
// TODO Auto-generated method stub
return this;
}
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
return size>0;
}
@Override
public String next() {
// TODO Auto-generated method stub
return list.get(--size);
}
}
d c v a