Java编程思想重点笔记（Java开发必看）

最新推荐文章于 2025-02-23 16:15:11 发布

小敏纸

最新推荐文章于 2025-02-23 16:15:11 发布

阅读量2.5w

点赞数 59

分类专栏： Java编程文章标签： java 编程思想笔记虚拟机多态

本文链接：https://blog.csdn.net/lanxuezaipiao/article/details/41822683

版权

本文深入探讨了Java编程思想中的关键知识点，包括多态性的理解，is-a关系与is-like-a关系的区别，以及运行时类型信息（RTTI）和反射的运用。内容涵盖构造函数的多态行为、代理模式与动态代理、即时编译器JIT技术，以及final关键字的作用。此外，文章还讨论了策略设计模式与适配器模式的区别，内部类的使用，以及不可变的String类型和序列化控制策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java编程思想，Java学习必读经典，不管是初学者还是大牛都值得一读，这里总结书中的重点知识，这些知识不仅经常出现在各大知名公司的笔试面试过程中，而且在大型项目开发中也是常用的知识，既有简单的概念理解题（比如is-a关系和has-a关系的区别），也有深入的涉及RTTI和JVM底层反编译知识。

1. Java中的多态性理解（注意与C++区分）

Java中除了static方法和final方法（private方法本质上属于final方法，因为不能被子类访问）之外，其它所有的方法都是动态绑定，这意味着通常情况下，我们不必判定是否应该进行动态绑定—它会自动发生。

final方法会使编译器生成更有效的代码，这也是为什么说声明为final方法能在一定程度上提高性能（效果不明显）。

如果某个方法是静态的，它的行为就不具有多态性：

     
     
     
      class StaticSuper {
         
          public static String staticGet() {
         
              return "Base staticGet()";
          }
      
          public String dynamicGet() {
         
              return "Base dynamicGet()";
          }
      }
      
      class StaticSub extends StaticSuper {
         
          public static String staticGet() {
         
              return "Derived staticGet()";
          }
      
          public String dynamicGet() {
         
              return "Derived dynamicGet()";
          }
      }
      
      public class StaticPolymorphism {
         
      
          public static void main(String[] args) {
         
              StaticSuper sup = new StaticSub();
              System.out.println(sup.staticGet());
              System.out.println(sup.dynamicGet());
          }
      
      }

输出：

Base staticGet()
Derived dynamicGet()

构造函数并不具有多态性，它们实际上是static方法，只不过该static声明是隐式的。因此，构造函数不能够被override。

在父类构造函数内部调用具有多态行为的函数将导致无法预测的结果，因为此时子类对象还没初始化，此时调用子类方法不会得到我们想要的结果。

   
   
   
    class Glyph {
       
        void draw() {
       
            System.out.println("Glyph.draw()");
        }
        Glyph() {
       
            System.out.println("Glyph() before draw()");
            draw();
            System.out.println("Glyph() after draw()");
        }
    }
    
    class RoundGlyph extends Glyph {
       
        private int radius = 1;
    
        RoundGlyph(int r) {
       
            radius = r;
            System.out.println("RoundGlyph.RoundGlyph(). radius = " + radius);
        }
    
        void draw() {
       
            System.out.println("RoundGlyph.draw(). radius = " + radius);
        }
    }
    
    public class PolyConstructors {
       
    
        public static void main(String[] args) {
       
            new RoundGlyph(5);
    
        }
    
    }

输出：

Glyph() before draw()
RoundGlyph.draw(). radius = 0
Glyph() after draw()
RoundGlyph.RoundGlyph(). radius = 5

为什么会这样输出？这就要明确掌握Java中构造函数的调用顺序：

（1）在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制0；
（2）调用基类构造函数。从根开始递归下去，因为多态性此时调用子类覆盖后的draw()方法（要在调用RoundGlyph构造函数之前调用），由于步骤1的缘故，我们此时会发现radius的值为0；
（3）按声明顺序调用成员的初始化方法；
（4）最后调用子类的构造函数。

只有非private方法才可以被覆盖，但是还需要密切注意覆盖private方法的现象，这时虽然编译器不会报错，但是也不会按照我们所期望的来执行，即覆盖private方法对子类来说是一个新的方法而非重载方法。因此，在子类中，新方法名最好不要与基类的private方法采取同一名字（虽然没关系，但容易误解，以为能够覆盖基类的private方法）。

Java类中属性域的访问操作都由编译器解析，因此不是多态的。父类和子类的同名属性都会分配不同的存储空间，如下：

   
   
   
    // Direct field access is determined at compile time.
    class Super {
       
        public int field = 0;
        public int getField() {
       
            return field;
        }
    }
    
    class Sub extends Super {
       
        public int field = 1;
        public int getField() {
       
            return field;
        }
        public int getSuperField() {
       
            return super.field;
        }
    }
    
    public class FieldAccess {
       
    
        public static void main(String[] args) {
       
            Super sup = new Sub();
            System.out.println("sup.filed = " + sup.field + 
                    ", sup.getField() = " + sup.getField());
            Sub sub = new Sub();
            System.out.println("sub.filed = " + sub.field + 
                    ", sub.getField() = " + sub.getField() + 
                    ", sub.getSuperField() = " + sub.getSuperField());
        }
    
    }

输出：

sup.filed = 0, sup.getField() = 1
sub.filed = 1, sub.getField() = 1, sub.getSuperField() = 0

Sub子类实际上包含了两个称为field的域，然而在引用Sub中的field时所产生的默认域并非Super版本的field域，因此为了得到Super.field，必须**显式地指明**super.field。

2. is-a关系和is-like-a关系

is-a关系属于纯继承，即只有在基类中已经建立的方法才可以在子类中被覆盖，如下图所示：

基类和子类有着完全相同的接口，这样向上转型时永远不需要知道正在处理的对象的确切类型，这通过多态来实现。
is-like-a关系：子类扩展了基类接口。它有着相同的基本接口，但是他还具有由额外方法实现的其他特性。

缺点就是子类中接口的扩展部分不能被基类访问，因此一旦向上转型，就不能调用那些新方法。