java知识梳理（基础）1 -10

江涛、

已于 2022-03-22 12:00:50 修改

阅读量618

点赞数 5

分类专栏： Java知识点文章标签： java 面试

于 2021-11-03 07:00:00 首次发布

本文链接：https://blog.csdn.net/weixin_44149429/article/details/121100980

版权

Java知识点专栏收录该内容

6 篇文章 0 订阅

订阅专栏

如有不足，还望指正

Java继承了C++语言的优点，去掉了C++中学习起来比较难的多继承、指针等概念，有简单性、面向对象、分布性、编译和解释性、稳健性、安全性、可移植性、高性能等特点。

1.java的三大特性是什么？

封装，即是隐藏一切可隐藏的东西，对外界只提供最简单的编程接口。比如，在一个类中，把数据和操作方法绑定起来，对数据的访问只能通过这些 get/set 方法（又称为接口）来实现。
继承，从已有类得到继承信息创建新类的过程。提供信息的叫父类（超类、基类），得到继承信息的叫子类（派生类）。既保证了延续性，又能实现可变性。。
多态：允许不同子类型对象对同一消息做出不同响应，即，用同样的对象，调用同样的方法，但是做了不同的事情。分为编译时多态（如：方法重载，同一个方法实现多个不同的逻辑，并可以在同一个类中实现。其实现的原理是，方法名相同，参数的个数或者类型不同）和运行时多态（如：方法重写，一个类中不可能两个定义一样的方法。因此，重写就是子类对父类定义的方法重新实现一次）。

2. java的特点有哪些？

简单性：Java语法是C++语法的一个“纯净版本”。这里没有头文件，指针运算（甚至指针语法），结构，联合，操作符重载，虚基类等等。不仅如此，Java开发环境远远超出大多数其他编程语言的开发环境。
面向对象：什么是面向对象？用木匠打一个比方，一个“面向对象”的木匠始终关注的是所制作的椅子，第二位才是所使用的工具；而一个“非面向对象”木匠首先考虑的是所使用的工具。在Java的世界里，一切皆对象。java的面向对象特性与C++旗鼓相当，与C++不同的点在于多重继承。在Java中，取而代之的是更简单的接口概念。而且与C++想比，Java提供了更丰富非运行时自省功能。
分布式（微服务）：Java有丰富的例程库，用于处理HTTP和FTP之类的TCP/IP协议。Java应用程序能够通过URL打开和访问网络上的对象，其便捷程度就好像访问本地文件一样。
健壮性：Java与C++最大的不同在于Java使用的指针模型可以消除重写内存和损坏数据的可能性（对于曾经花费几个小时来检查由于指针bug而引起内存冲突的人来说，一定很喜欢Java的这一特性）。不仅如此，Java编译器能够检测许多在其他语言中仅在运行时才能够检测出来的问题。
安全性：Java适用于网络/分式式环境。为了达到这个目标，在安全性方面投入了大量的精力。使用Java可以构建防病毒，防篡改的系统。从一开始，Java就设计出能够防范常见的各种攻击：（1）运行时堆栈溢出。蠕虫和病毒常用的攻击手段。（2）破坏自己进程空间之外的内存。（3）未经授权读写文件。
体系结构中立：编译器生成一个体系结构中立的目标文件格式，这是一种编译过的代码，只要有Java运行时系统，这些编译后的代码就可以在许多处理器上运行。Java编译器通过生成与特定计算机体系结构无关的字节码指令来实现这一特性。精心设计的字节码不仅可以很容易的在任何机器上解释执行，而且还可以动态地翻译成本地机器代码。
可移植性：与C/C++不同，Java规范中没有“依赖具体实现的地方”。基本数据类型的大小以及有关运算都做了明确的说明。例如，Java中的int永远是32位的整数，二在C/C++中，int可能是16位整数，32位整数，也可能是编译器提供商指定的其他大小。在Java中，数据类型具有固定的大小，这消除了代码代码移植时令人头疼的主要问题。
解释型：Java解释器可以再任何移植了解解释器的机器上执行Java字节码。由于链接是一个增量式且轻量级的过程。所以开发过程也变得更加快捷，更加具有探索性。
高能性：尽管对解释后的字节码性能已经比较满意，但是在某些场合下可能需要更加高效的性能。字节码可以（在运行时刻）动态的翻译成对应运行这个应用的特定CPU的机器码。
多线程：Java在当时很超前，他是第一个支持并发程序设计的主流语言，多线程可以带来更好的交互影响和实时行为。并发程序设计绝非易事，但是Java在这方面表现出色，可以很好的管理这个工作。
动态性：Java与C/C++相比更具有动态性。它能够适应不断发展的环境。库中可以自由的添加新方法和实例变量，而对客户端没有任何影响。在Java中找出运行时类型信息十分简单。

3. JDK 、JRE 和JVM

JDK：Java Development Kit 的简称，是java开发工具包，提供了java的开发环境和运行时环境。
JRE： Java Runtime Environment 的简称，java运行环境，为java提供了运行环境。
JVM：Java Virtual Machine(Java虚拟机)的缩写。它是java运行环境的一部分，是一个虚构出来的计算机，它是通过在实际的计算机上仿真模拟各种计算机功能来实现的。JVM是用来解析和运行Java程序的。

具体来说，就是JDK包含了JRE，同时还包含编译java源码的编译器javac，还有很多java程序调试分析的工具。JDK 和 JRE 中都包含 JVM。总的来说，如果你需要运行 java 程序（只运行），只需安装 JRE 就可以了，如果你需要编写 java 程序（开发），需要安装 JDK。

举个例子，JDK就像是锅碗瓢盆灶，在厨师（开发者）手中可以炒出美味佳肴，JRE就像是盛放食品的容器，顾客（用户）不需要用到那些工具。

4. java程序是如何执行的？

    Java 代码编译成字节码, 从文件后缀来看.java编译成.class 类型的文件；
    class 文件放置到 Java 虚拟机，这个虚拟机通常指的是 Oracle 官方自带的 Hotspot JVM；
    Java 虚拟机使用类加载器 Class Loader 装载 class 文件；
    加载完成之后，会进行字节码校验，字节码校验通过之后 JVM 解释器会把字节码翻译成机器码交由操作系统执行。

5. java中数据类型

byte、short、int、long、float、double、boolean、char

原始数据类型对应的封装对象：

byte--Byte short--Short int--Integer long--Long float--Float double--Double boolean--Boolean char--Character

例：

Integer x = null；
int y = x.intValue();
//编译通过报空指针异常

Integer a = 10 ； //自动装箱，编译器执行Integer.valueOf(100)
                 // 在Java SE5之前，自动装箱要这样写：Integer a = new Integer(10);

int b = a；//自动拆箱，编译器执行i.intValue()

//注意 因为自动拆装箱，要留意a的null值情况

 Integer a = 200;  
 Integer b = 200;          
 System.out.println("a==b的结果: "+(a==b));  //输出  a==b的结果：false
             
 Integer c = 100;  
 Integer d = 100;  
 System.out.println("c==d的结果: "+(c==d));  //输出  c==d的结果：true

为什么会出现上面输出结果不同呢，源码一探究竟：

//Integer的valueOf方法的具体实现：
public static Integer valueOf(int i) {
      if(i >= -128 && i <= IntegerCache.high)
          return IntegerCache.cache[i + 128];
      else
          return new Integer(i);
    }
//


private static class IntegerCache {
        static final int high;
        static final Integer cache[];

        static {
            final int low = -128;

            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

//以上2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，
//便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。
//所以，c和d为100，输出结果true,a和b为200，输出false

6.a=a+b/a+=b的区别？

+=操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型,而a=a+b则不会自动进行类型转换.如：

byte a = 127;
byte b = 127;
b = a + b; // 报编译错误:cannot convert from int to byte
b += a; //编译运行正常

7.能把int强制转换byte嘛？超出byte范围会怎样？

我们可以做强制转换，但是 Java 中 int 是 32 位的，而 byte 是 8 位的，所以，如果强制转化，int 类型的高 24 位将会被丢弃，因为byte 类型的范围是从 -128 到 127。

8.== 和 equals 的区别是什么？

对于基本类型和引用类型 == 的作用效果是不同的

基本类型：比较的是值是否相同；
引用类型：比较的是引用是否相同；

如下所示：

String x = "string";
String y = "string";
String z = new String("string");
System.out.println(x==y); // 输出结果true
System.out.println(x==z); // 输出结果false
System.out.println(x.equals(y)); //输出结果 true
System.out.println(x.equals(z)); // 输出结果true

// x 和 y 指向的是同一个引用，所以 == 也是 true
// new String()方法则重写开辟了内存空间，所以 x==z 结果为 false，
//equals 比较的一直是值，所以结果都为 true

equals 本质上就是 ==，不过 String 和 Integer 等重写了 equals 方法，把它变成了值比较。如下：

class User{
    public User(String name) {
        this.name = name;
    }
 
    private String name;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
 
Cat c1 = new User("江濤");
Cat c2 = new User("江濤");
System.out.println(c1.equals(c2)); // 结果为false

//源码如下
public boolean equals(Object obj) {
    return (this == obj);
}

//equals 本质上就是 ==

String s1 = new String("老王");
String s2 = new String("老王");
System.out.println(s1.equals(s2)); //结果true

//String 的 equals 方法，String 重写了 Object 的 equals 方法，把引用比较改成了值比较，如下：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

总结：== 对于基本类型来说是值比较，对于引用类型来说是比较的是引用；而 equals 默认情况下是引用比较，只是很多类重新了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

9.两个对象的 hashCode()相同，则 equals()也一定为 true？

错误，两个对象的 hashCode()相同，equals()不一定 true，代码：

String str1 = "通话";
String str2 = "重地";
 
System.out.println(String.format("str1：%d | str2：%d", str1.hashCode(),str2.hashCode()));//输出结果：str1：1179395 | str2：1179395


System.out.println(str1.equals(str2));//输出结果：false

//显然，hashcode相同的值equals不一定为true

10.final在java中的作用？

final可以修饰变量、方法和类