Java教程

java编程思想第四版第十章总结

本文主要是介绍java编程思想第四版第十章总结,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1. 内部类的特性

  • 他允许你把一些逻辑相关的类组织在一起。

2. 使用.this

  • 如果你需要在内部类中堆外部类进行应用,可以使用外部类的名字后面加.this。下面展示了如何使用 .this
    package net.mindview.innerclasses;
    
    public class DotThis {
        void f(){
            System.out.println("DotThis.f()");
        }
        
        public class Inner {
            public DotThis outer() {
                System.out.println(DotThis.this);
                return DotThis.this;
            }
        }
        
        public Inner inner(){
            return new Inner();
        }
        
        public static void main(String[] args) {
            DotThis dt = new DotThis();
            DotThis.Inner di = dt.inner();
            di.outer().f();
        }
    
    }

     

 3.使用.new

  • 如果想要创建某个外部类的内部类,可以使用外部类对象.new 内部类:
  • 如果想new一个内部类, 不能使用外部类.new 内部类。必须使用外部类的对象来创建内部类的对象。    用法如下:
    package net.mindview.innerclasses;
    
    public class DotNew {
        
        public class Inner {
            
        }
        public static void main(String[] args) {
            DotNew dn = new DotNew();
            DotNew.Inner di = dn.new Inner();
        }
    }

     

4. 方法的内部类

  • 这里只说两点:
    • 方法的内部类有效作用域是在方法内,方法外部可以调用
    • 方法的内部类,并不是说方法被调用的时候才创建了,实际上,这个类和其他类没有什么不同,他们在使用之前,已经经过编译了.
      package net.mindview.innerclasses;
      
      /**
       * 方法内部类的作用域就在方法内,方法外不可以访问.
       * @author samsung
       *
       */
      public class Parcel5 {
          public Destination destination(String s){
              //在方法里定义了一个内部类
              class PDestination implements Destination{
                  private String label;
                  public PDestination(String label){
                      System.out.println(this);
                      this.label = label;
                  }
                  @Override
                  public String readLabel() {
                      return label;
                  }
              }
              
              return new PDestination(s);
          }
          public static void main(String[] args) {
              Parcel5 p = new Parcel5();
              System.out.println(p.destination("上海").readLabel());
              System.out.println(p.destination("北京").readLabel());
          }
      
          /**
           * 注意:PDestination定义在方法里面,并不是说只有调用方法的时候,这个类才被创建.
           * 实际上,这个类和其他类一样,已经经过编译了.
           */
      }

       

5. 定义在作用域内的内部类, 此作用域在方法的内部.

  • 定义在方法作用域内部的类, 只在作用域内部有效
package net.mindview.innerclasses;

public class Parcel6 {
    private void internalTracking(boolean b){
        if(b){
            class TrackingSlip{
                private String id;
                TrackingSlip(String s){
                    id = s;
                } 
                
                String getSlip(){
                    return id;
                }
            }
            
            TrackingSlip ts = new TrackingSlip("100");
            String s = ts.getSlip();
        }
        //作用域外不可使用
        //TrackingSlip ts = new TrackingSlip("100");
    }
    
    public void track(){
        internalTracking(true);
    }
    
    public static void main(String[] args) {
        Parcel6 p = new Parcel6();
        p.track();
    }
}

 

6.匿名内部类

  • 默认构造器匿名内部类
    package net.mindview.innerclasses;
    
    public class Parcel7 {
        public Contents contents(){
            //定义了一个匿名内部类.将返回值和创建类放在了一起
            return new Contents(){
                private int i = 11;
                @Override
                public int value() {
                    return i;
                }
            };
        }
        public static void main(String[] args) {
            Parcel7 p = new Parcel7();
            Contents c = p.contents();
            System.out.println(c.value());
    
        }
    
    }

     

  • 代参数构造器的匿名内部类
    package net.mindview.innerclasses;
    
    public class Wrapping {
        
        private int i;
        public Wrapping(int x){
            this.i = x;
        }
        public int value(){
            return i;
        }
    }
    package net.mindview.innerclasses;
    
    public class Parcel8 {
        public Wrapping wrapping(int x){
            return new Wrapping(x){
                @Override
                public int value(){
                    return super.value()*47;
                }
            };
        }
        
        public static void main(String[] args) {
            Parcel8 p = new Parcel8();
            Wrapping w = p.wrapping(20);
            System.out.println(w.value());
        }
    
    }

    这里需要注意的是, 虽然Wrapping是一个导出类, 却依然被当成了一个接口来使用.

  • 匿名内部类中使用外部对象, 这外部的这个对象必须是final的
    package net.mindview.innerclasses;
    
    public class Parcel9 {
        public Destination destination(final String x){
            final String m = null;
            //匿名内部类
            return new Destination(){
                //在内部类中使用到了外部的对象
                private String label = m;
                private String abc = x;
                @Override
                public String readLabel() {
                    return label;
                }
            };
        }
        public static void main(String[] args) {
            Parcel9 p = new Parcel9();
            System.out.println(p.destination("20").readLabel());
        }
        
        /**
         * 定义一个匿名内部类, 如果希望在匿名内部类中使用外部的对象, 
         * 那么编译器要求外部类的这个参数必须是final的. 如果你没有将这个类定义为final
         * 编译器会报错
         */
    
    }

     

  • 在匿名内部类中使用类似构造器的行为. 我们知道匿名内部类没有类名, 因此他不可能有命名构造器. 但通过实例初始化可,就鞥够达到为匿名内部类创建一个构造器的效果
    package net.mindview.innerclasses;
    
    abstract class Base{
        public Base(int i){
            System.out.println("Base构造器, i=" + i);
        }
        
        public abstract void f();
    }
    public class AnonymousConstructor {
        /**
         * 此处的i不要求是final的,因为这个i只是传递给了匿名
         * 变量的构造器,并没有在匿名内部类内部使用.
         */
        public static Base getBase(int i){
            return new Base(i){
                {
                    System.out.println("这里可以类似构造器进行初始化");
                }
                @Override
                public void f() {
                    System.out.println("匿名函数f()");
                }
                
            };
        }
        public static void main(String[] args) {
            AnonymousConstructor amc = new AnonymousConstructor();
            amc.getBase(100).f();
        }
    
    }

     

 7. 再谈工厂设计模式.

  再上一章中说了工厂设计模式. 本书中的案例是对象工厂设计模式. 来看看是怎么写的

package net.mindview.innerclasses.factory.MethodFactory;
/**
 * 服务类
 */
interface Service{
    void method1();
    void method2();
}

/**
 * 工厂类
 */
interface ServiceFactory {
    Service getService();
}

class Implementation1 implements Service{

    @Override
    public void method1() {
        System.out.println("Implementation1 method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation1 method1");
    }
    
}

class Implementation2 implements Service{

    @Override
    public void method1() {
        System.out.println("Implementation2 method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation2 method1");
    }
    
}

class ImplementationFactory1 implements ServiceFactory{
    @Override
    public Service getService() {
        // TODO Auto-generated method stub
        return new Implementation1();
    }
}

class ImplementationFactory2 implements ServiceFactory{
    @Override
    public Service getService() {
        // TODO Auto-generated method stub
        return new Implementation2();
    }
}

public class Factories {
    public static void serviceSustomer(ServiceFactory factory){
        factory.getService().method1();
        factory.getService().method2();
    }
    public static void main(String[] args) {
        serviceSustomer(new ImplementationFactory1());
        serviceSustomer(new ImplementationFactory2());
    }

}

  我们还可以将这种方式以内部类的方式来实现

package net.mindview.innerclasses.factory.methodFactoryInnerClass;
/**
 * 服务类
 */
interface Service{
    void method1();
    void method2();
}

/**
 * 工厂类
 */
interface ServiceFactory {
    Service getService();
}

/**
 * 每一种服务,提供一种工厂. 这种工厂专门创建这种服务.
 */
class Implementation1 implements Service{
    private Implementation1(){}
    @Override
    public void method1() {
        System.out.println("Implementation1 method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation1 method1");
    }
    
    //让工厂在内部实现
    public static ServiceFactory factory = new ServiceFactory(){
        @Override
        public Service getService() {
            return new Implementation1();
        }
        
    };
    
}

class Implementation2 implements Service{

    @Override
    public void method1() {
        System.out.println("Implementation2 method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation2 method1");
    }

    //让工厂在内部实现
    public static ServiceFactory factory = new ServiceFactory(){
        @Override
        public Service getService() {
            return new Implementation2();
        }
        
    };
    
}

public class Factories {
    public static void serviceSustomer(ServiceFactory factory){
        factory.getService().method1();
        factory.getService().method2();
    }
    public static void main(String[] args) {
        serviceSustomer(Implementation1.factory);
        serviceSustomer(Implementation2.factory);
    }
}

 

  我的理解是: 第一种工厂的含义是: 我现在需要一种服务, 然后我找到对应的工厂, 为我提供服务. 工厂再去找对应这种服务的实体.

  而第二种方式呢, 我现在需要服务. 直接就去找这种服务对应的工厂就可以了. 也就是工厂内置了. 就像大公司下有多个子公司, 每个子公司都有自己的工厂.我要那种类型的东西,他就自己给生产了

8. 嵌套类

  如果内部类对象预期外围类对象之间不需要有联系, 那么可以将内部类声明为static的。这种累通常称为嵌套类。要想理解static定义的内部类的含义,就必须记住,普通的内部类对象隐式地保存了一个引用,指向创建他的外围类对象。然而,当内部类是static的时候, 就不是这样了。嵌套类意味着:

  1. 要创建嵌套类的对象, 并不需要外围类的对象。
  2. 不能从嵌套类的对象中访问非静态的对象
  3. 普通的内部类不能有static数据和static字段,也不能包含嵌套类,但是嵌套类可以有这些东西
    package net.mindview.innerclasses;
    
    public class Parcel11 {
        //ParcelContent被定义为static的,所以是一个嵌套类
        private static class ParcelContent implements Contents {
            int i = 11;
            @Override
            public int value() {
                return i;
            }
        }
        
        //ParcelDestination 是一个嵌套类. 被定义为static的.所以,它内部可以的有static的成员和方法
        private static class ParcelDestination implements Destination {
            private String label;
            private ParcelDestination(String label){
                this.label = label;
            }
            @Override
            public String readLabel() {
                return label;
            }
            
            public static void f(){
                System.out.println(AnotherLabel.x);
                //b()方法是访问不到的
                //AnotherLabel.b();
            }
            static int x = 10;
            //他是嵌套在嵌套类内部的嵌套类.
            static class AnotherLabel{
                //内部定义了两个和外部一样的成员方法, 竟然不冲突
                public static void f(){
                    System.out.println("这时静态类的静态方法");
                }
                static int x = 10;
                //嵌套类中的非静态方法不能被外部访问到. 所以这个方法没有任何意义
                public void b(){
                    System.out.println("这时静态类中的静态方法b()");
                }
            }
        }
        
        public static Contents getContents(){
            return new ParcelContent();
        }
        
        public static Destination getDestination(String s){
            return new ParcelDestination(s);
        }
        
        public static void main(String[] args) {
            System.out.println(getContents().value());
            System.out.println(getDestination("北京").readLabel());
            
            //嵌套类中,不能访问非静态方法
            //ParcelDestination.readLabel();
            //但是可以方法静态方法
            ParcelDestination.f();
            
            //嵌套类的使用方式是,类似于静态方法. 将其作为静态方法来使用.
            ParcelDestination.AnotherLabel.x=1;
            System.out.println(ParcelDestination.AnotherLabel.x);
            
            ParcelDestination.AnotherLabel.f();
            //下面这样写是不对的
            //ParcelDestination.AnotherLabel.b();
        }
    
    }

    观看上面说的文字,会有些难以理解,所以, 将这段代码敲一遍,就理解什么意思了。动手很重要啊

9. 接口内部的类

  • 首先,接口里不能放置任何代码, 但是嵌套类可以.
  • 你放到接口中的任何类都自动式public static的.
  • 你可以在内部类中实现外围类的接口. 示例如下:
    package net.mindview.innerclasses;
    /**
     * 定义在接口内部的类
     */
    public interface ClassInInterface {
        void howdy();
        //这里static必须是显示标记出来的,否则这个类将不能运行
        static class Test implements ClassInInterface {
    
            @Override
            public void howdy() {
                System.out.println("Howdy!");
            }
    
            public static void main(String[] args) {
                Test t = new Test();
                t.howdy();
            }
        }
    }

    注意, 如果想运行main方法, 这里的嵌套类必须是static的.

 

  • 如果想创建某些公共代码, 使得他们可以被某个接口的所有实现类所共用, 那么使用接口内部的嵌套类会显得很方便.
  • 例如: 我们可以在每个类中写一个mian方法用来测试这个类, 这样做有一个缺点, 那就是要写好多遍,而且, 必须通过编译器的编译, 我们可以使用嵌套类改善
    package net.mindview.innerclasses;
    
    public class TestBed {
        public void f(){
            System.out.println("f()");
        }
        
        static class Testers{
            public static void main(String[] args) {
                TestBed t = new TestBedTest();
                t.f();
            }
        }
    }

    再说的白话一点,就是在接口中定义一个这样的嵌套类. 然后定义mian方法, 在main方法中使用嵌套类. 当有一个新的对象继承了这个类的时候, 就在这个类中的main方法进行测试就好了. 这样的好处是, 当我打包发布到正式环境的时候, 我想删除所有的main方法,因为他们的存在也会被编译器编译, 降低效率. 如果只有一个接口的嵌套类中定义的main方法,那么删起来就方便很多了。不明白的话,在看下面这个例子,就懂了

    package net.mindview.innerclasses;
    /**
     * 定义在接口内部的类
     */
    public interface ClassInInterface {
        void howdy();
        //这里static必须是显示标记出来的,否则这个类将不能运行
        static class Test implements ClassInInterface {
    
            @Override
            public void howdy() {
                System.out.println("Howdy!");
            }
    
            public static void main(String[] args) {
                //测试第一个实现了接口的类
                ClassInInterface t = new Test();
                t.howdy();
                //测试第二个实现了接口的类
                ClassInInterface t1 = new ClassInInterfaceTest();
                t1.howdy();
            }
        }
    }
    package net.mindview.innerclasses;
    
    public class ClassInInterfaceTest implements ClassInInterface{
    
        @Override
        public void howdy() {
            System.out.println("hhhh");
        }
    }

     

  • 接口中嵌套类如何创建实例化对象。 参考习题20
    package net.mindview.innerclasses.test20;
    interface InnerInInterface{
        static class Inner{
            public Inner(){
                System.out.println("嵌套类构造方法");
            }
        }
    }
    
    public class Test20 {
        public static void main(String[] args) {
            //直接使用  new 外围类.嵌套类
            InnerInInterface.Inner inner = new InnerInInterface.Inner();
        }
    }

     

10. 从多层嵌套类中访问外部类的成员

  注意下面这个例子是如何创建内部类的。

package net.mindview.innerclasses;
/**
 * 多层嵌套类访问外部成员
 */

class A{
    private void f(){};
    class B{
        private void b(){};
        class C {
            void c(){
                f();
                b();
            };
        }
    }
}
public class MutliNestingAccess {

    public static void main(String[] args) {
        A a = new A();
        A.B b = a.new B();
        A.B.C c = b.new C();
        c.c();
    }

}

iooo

 

这篇关于java编程思想第四版第十章总结的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!