《Think in Java》阅读笔记·第二卷

其他 2018-05-07 12:17:40 阅读次数: 3

内部类

从外部类的非静态方法之外的任意位置创建某个内部类的对象，都需要以外部类.内部类的格式指明对象类型

内部类拥有外围类的所有元素的访问权

外围类对象创建一个内部类对象时，此内部类对象会秘密地捕获一个指向那个外围类对象的引用。
在外围类静态方法中创建内部类对象源码如下：

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

猜你喜欢

转载自blog.csdn.net/figurers/article/details/79796226
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022