android--java必会问题

最新推荐文章于 2025-05-23 09:10:05 发布

原创最新推荐文章于 2025-05-23 09:10:05 发布 · 187 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

java基础

本文深入探讨Java中final和static关键字的用法，包括final修饰类、方法和变量的规则，以及static修饰变量、方法、代码块和类的特性。同时解析了Strings='abc'在内存中的存储方式。

final 修饰什么？

Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。下面就从这三个方面来了解一下final关键字的基本用法。
　　1.修饰类
　　当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。
　　2.修饰方法
　　下面这段话摘自《Java编程思想》第四版第143页：
　　“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“
　　因此，如果只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final的。
　　注：类的private方法会隐式地被指定为final方法。
　　3.修饰变量
　　修饰变量是final用得最多的地方，首先了解一下final变量的基本语法：
　　对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
一句话：final可以修饰：类变量方法；final修饰的类不能被继承；final修饰的方法不能被重写；final修饰的变量是一个常量，只能背赋值一次。

static关键字能修饰什么？

static详解：https://www.cnblogs.com/dolphin0520/p/10651845.html
static关键字是Java中常用的关键字之一，可能最常用的就是修饰变量和方法了，但是仅仅知道这些还远远不够。问题虽然很小，但是却反映了对Java的了解程度。

static修饰变量和方法

static可以修饰变量，这个变量属于类本身，不需要创建实例就可以直接获取到值。
static可以修饰方法，这个方法属于类本身，同样，不要创建实例就可以通过类调用。

需要了解的是，static修饰的变量或方法属于类的静态资源，是所有实例共享的，另外静态方法内部是不能访问非静态方法的，因为静态资源是在类加载的时候就建立好的，而类加载时非静态方法需要类new的时候才能创建，一前一后的顺序所以导致了Java静态方法不能访问非静态资源的结果，当然反之肯定是可以的了。

static修饰代码块

static修饰的代码块是静态代码块，也具有静态的特点，属于类本身，在加载时只需要加载一次，也就是说，如果加载过这个代码块，就不会再加载了。

static修饰类
static修饰类只有一种情况，那就是这个类属于静态内部类，接触过Android开发的话可能遇见过很多这样的静态内部类，如WindowManager.LayoutParams类，LayoutParams就是WindowManager类下的静态内部类，它的源码如下所示：

public interface WindowManager extends ViewManager {
    public static class LayoutParams extends ViewGroup.LayoutParams implements Parcelable {
        //内部实现
    }
}

普通类是不允许声明为静态的，只有内部类才可以。

被static修饰的内部类可以直接作为一个普通类来使用，而不需先实例一个外部类。

public class OuterClass {  

    public static class InnerClass {  

        InnerClass(){  
            System.out.println("===== 我是一个内部类'InnerClass' =====");  
        }  
    }  
}

public class TestStaticClass {  

    public static void main(String[] args) {  

         // 不需要先new一个OutClass的对象  
        OuterClass.InnerClass inner = new OuterClass.InnerClass();  
    }  
}

如果没有用static修饰InterClass，则只能按如下方式调用：

public class OuterClass {  

    public class InnerClass{  

        InnerClass(){  
            System.out.println("===== 我是一个内部类'InnerClass' =====");   
        }  
    }  
}

public class TestStaticClass {  

    public static void main(String[] args) {  

        // 需要先new一个OuterClass的对象outer
        // 然后通过outer.new生成内部类的对象
        OuterClass outer = new OuterClass();  
        OuterClass.InnerClass inner = outer.new InnerClass();  
    }  
}

import static
这个算是比较冷门的，但是知识不怕多，import static是JDK1.5之后的新特性，这两个关键字连用可以指定导入某个类中的指定静态资源。

import static java.lang.Math.*;

 public class A
{
     public static void main(String[] args)
     {
         System.out.println(sin(2.2));
   }
}

不需要再加Math.sin()的Math了，还是很方便的，但是可读性不高，不建议这样写。

修饰内部类和外部类区别

Java内部类详解：https://www.cnblogs.com/dolphin0520/p/3811445.html

java 内部类和静态内部类的区别：https://www.cnblogs.com/aademeng/articles/6192954.html
内部类和外部类的区别和联系：https://www.cnblogs.com/NYfor2018/p/9466476.html

String s = ‘abc’ 是在哪块内存中存储

答：方法区的常量池

String s=“abc” 和 String s1=new String(“abc”)内存分析

String s=”abc”

s是栈内变量，它的内存保存的是常量池的常量字符串对象对象”abc”的地址。常量池中的每个值只有一份。String s2 = “abc”;

s和s2两个变量指向的是同一个地址，因此s==s2结果为true

String s1=new String(“abc”);
s1是栈内变量，它的内存保存的是堆中的new String对象的地址，new String在堆中生成对象，并用常量池的字符串对象”abc”初始化堆中的对象，所以堆中的对象的内存的内容和常量池对象的内存的内容一样，但是是不同的两个对象

因此s==s1的结果是false。==比较的是两对象的引用，因此结果为false.

s.equals(s1)的结果是true，因为String的equals方法比较的是对象的内容。

String s = “abc”到底做了啥

作为开发人员在类里面定义String变量几乎是家常便饭，亦或是日常了，照理说String是个对象，为什么我们定义的时候不是直接 new String(“abc”);

而是直接写了对象内容，难道不觉得有点诡异吗？

String s1 = “abc”;

String s2 = “abc”;

String s3 = new String(“abc”);

System.out.println("s1 = s2? " + (s1 == s2)); //true

System.out.println("s1 = s3? " + (s1 == s3)); //false

怎么去理解上面的结果，大家知道字面量赋值是在常量池，常量池其实是一张表：

常量池（Constant Pool）指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。JVM虚拟机为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（String,Integer和 Floating point常量）和对其他类型，字段和方法的符号引用。对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的，对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。

1.Strings = “abc”;
创建过程分析：在class文件被JVM装载到内存中，JVM会创建一块String Pool（String缓冲池）。当执行String s = “abc”;时，JVM首先在String Pool中查看是否存在字符串对象“abc”（如何查看呢？用equals()方法判断），如果已存在该对象，则不用创建新的字符串对象“abc”，而直接使用String Pool中已存在的对象“abc”，然后将引用s指向该对象；如果不存在该对象，则先在String Pool中创建一个新的字符串对象“abc”，然后将引用s指向String Pool中创建的新对象。
注意：使用“字符串常量”引号创建的字符串对象时，在编译期就已经确定将该对象存储到String Pool中了。因此，String s = “abc”只会在编译期，在String Pool中创建一个对象。

2.new String(“abc”);

将会在堆中创建对象，查看下String构造方法源码

private final char value[];

public String(String original) {
　 this.value = original.value;
　　this.hash = original.hash;
}

很明显在堆中String其实是char数组维护一组数据，前者是表后者是数组，结构不一样，地址存放不一样，引用自然不一样，虽然内容是一样！