Java面试集合（七）

矫情吗；* 2021-09-16 05:18 368阅读 0赞

![标题图][1240]

## 前言： ##

[Java面试集合（六）][Java]  
的回顾，对于`final`可以修饰常量，方法，和类，一旦常量定义好后就不可改变，而方法，用`final`来修饰方法，方法不可重载，继承，重写，`final`用来修饰类，该类不能被继承。

抽象`abstract`，不能够有对象，即不能进行实例化，但又构造方法，在抽象修饰类时，这个抽象类，不一定有抽象方法，但是在类中有抽象方法，那么这个类就一定是抽象类。

> 在抽象类中的所有抽象方法，子类一旦继承抽象类，就要重写父类（即抽象类）中的所有抽象方法，但是连子类都是抽象类就不用，如果该子类继承了抽象的父类，子类也是抽象类，就不用。

抽象方法是没有方法体的，因为抽象方法是抽象功能的，在子类中实现，抽象方法可以被重载，即参数等不同。抽象方法不能再用`static/final/private`来修饰。

接口`interface`的抽象方法用`public abstract`来修饰，属性用`public static final`来修饰。

> 接口是没有实例化对象的，也没有构造方法

内部类的分类为，方法的**内部类，成员的内部类，静态内部类，匿名内部类。**

包的基础（`package`）和垃圾回收机制基础。

## 1. Object对象 ##

所有类的父类`Object`，因为任何一个类都是直接或者间接的继承`Object`类，都是`Object`的子类，`Object`是类层次结构的根类，存在`java.lang.Object`中。

`getClass`可以获取对象的实际类型  
`toString`可以返回对象的地址  
`equals`可以判断两个对象是否相等

对象和类的关系进行判断：`instanceof`

class A { }
    class B extends A { }
    interface D{ }
    class C extends B implements D { }

B b = new C();
    b instanceof A --- true
    b instanceof B --- true
    b instanceof C --- true 
    b instanceof D --- true

> 构造方法：`public Object()`

*  `finalize()`方法：java的垃圾回收时机
 *  `Object的toString()`方法：返回的是对象的字符串形式
 *  `Object的equals()`方法：比较两个对象是否相等

复习：

*  二进制：`以0b/0B作为开头` （0~1，满2进1）
 *  八进制：`以0作为开头`（0~7，满8进1）
 *  十进制：`没有特殊标识`（0~9，满10进1）
 *  十六进制：`以0X/0x作为开头`（09,af，满16进1）

> 进制间的转化

*  十进制转二进制：不断除以2，然后取余数
 *  二进制转十进制：从最低位依次乘以2的位次次幂，然后求和

#### 同理： ####

十进制转其他进制：除以对应的进制数，然后取余数
    其他进制转十进制：从最低位依次开始，按位次乘以进制的位次次幂，然后求和

二进制转八进制，也是从低位开始，每三位二进制为一组，产生一个八进制数字，最高位不足三位，就补0，凑齐三位即可。

> 口诀：三变一

八进制转二进制，每一位八进制数都会产生三位二进制数字，不足三位就补0即可。

> 口诀：一变三

#### 同理 ####

二进制转十六位进制：口诀为四变一
    十六位进制转二进制：口诀为一变四

> Bin为二进制，Oct为八进制，Dec为十进制，Hex为十六进制

## 2. String类 ##

在 `Java`中的字符串属于对象，那么`Java` 中提供了 `String` 类来创建和操作字符串，即是使用对象；因为`String`类修饰的字符一旦被创建就不可改变，所以当对字符串进行修改的时候，需要使用到`StringBuffer` 和 `StringBuilder` 类。

> `String`类是用来修饰字符串的，字符串是一种特殊的对象，一旦初始化就不可被改变，用`String`修饰的字符串变量是不可以被改变的。

**例子：**

//定义一个字符串
    String str = "hello world";
    String str = new String("hello world");

对于`String`类，存在`java.lang.String`中，`String`类代表字符串，如何实现字符串的字面值，就是用此类来实例的。

`String`类，代表字符串的类，如何的字符串都是`String`的对象。字符串是作为常量，被双引号包着的为常量，被初始化即不可被更改。那么接下来举个例子效果。

String i = "123";
    System.out.println("i="+i);
    //结果为
    i=123
    
    如果添加以下
    String i = "123";
    i = "12"
    System.out.println("i="+i);
    //结果为
    i=12
    
    // 看到这个效果，你会认为不是改了吗？
    // 其实不是的，而是新创建了一个对象而已。

在`String`中，对象是不可变的，但可以共享的。那么怎么理解是共享的呢？这里引出常量池的概念，如下：

//多个引用指向同一个字符串
    String str1 = "dashu"
    String str2 = "dashu";
    System.out.println(str1==str2);
    //结果
    true

为`true`代表它们同时指向一个字符串，即为对象。创建了一个`str1`对象，字符串常理为`"dashu"`，那么再次创建一个对象时，常理名相同，在常量池中发现有相同的`"dashu"`，那么就同时指向一个值。

常量池是放置常量的，如果有相同的值，就不用创建对象，第一个创建的字符串放在常量池中，如果要用的时候，就拿来用。

// 字符串在底层是以字符数组形式来存储的
    String str = “ab”; 
    String str = new String(“ab”);

String s = “a”; s = s + “b”;

//内容相同，但是创建方式不同的情况
    String str3 = "abc"
    String str4 = new String ("abc");
    System.out.println(str3==str4);//false
    System.out.println(str3.equals(str4));//true
    //结果
    false
    true

// 100个元素拼接成一个字符串，使用+进行拼接
    // 整个过程产生301个
    String[] arr = { /*100个元素*/ };
    // 为 1
    String str = “”;
    
    for(String s : arr){
    str += s; 
    // 每拼接1次，要多产生3个对象。
    // 一共100个元素，拼接100次，意味着要多产生300个元素
    }

> `String`代表是字符串的类，而字符串本身就是常量，字符串在底层是以字符数组形式存储的，字符串是共享的，在常量池中

#### StringBuffer ####

对于字符串是常量，它的值在创建后时不可以改变的，但字符串缓冲区支持可变的字符串。

`StringBuffe`r类为`java.lang`中，`StringBuffer`为字符串缓冲，`StringBuffer`为线程安全的可变字符序列，类似`String`的字符串缓冲区，缓冲区不能改，但里面可以改，通过某方法可以改变序列的长度和内容。

> `StringBuffer`提供了主要的两种方法，一，`append（）` ,二， `inset（）`

`StringBuffer`为一个字符串缓冲区，相对于一个容器，长度是可变的，可以存储任意类型数据，是将任意数据转变为字符串进行存储，`StringBuffer`提供了对数据的很多的操作功能。

**例子：**

StringBuffer sb = new StringBuffer();
    sb.append("da");
    sb.append("shu");
    System.out.println(sb);
    //sb.append("da").append("shu");

如果要操作数据，要转换为字符串。`StringBuffer`所有存储的元素都被转成字符串才可使用。

String str = sb.append("da").append("shu").toString();

在指定位置插入元素

sb.insert(2,"hehe");//插入

`StringBuilder`的效率要远高于用“+”，需要拼接多个字符串，建议使用`StringBuilder`。

#### StringBuffer和StringBuilder的区别 ####

`StringBuilder`是线程不安全的，`StringBuffer`是线程安全的

`StringBuilder`为`java.lang`类，是一个可变的字符序列，提供了与`StringBuffer`兼容的`API`，`StringBuffer`和`StringBuilder`方法是一模一样的。

`StringBuilder`不同步，不安全。如果同时`append(),delete(),insert(),`会导致出错，多线程访问不安全，添加修饰`synchronized`即可。在`jdk1.5`版本后，推出`StringBuilder`被用作一个`StringBuffer`的简易替换，用在字符串缓冲区被单个线程使用的时候。

## 3. 装箱与拆箱 ##

封装类有：`Byte , short , Integer , Character , long , Float , Double` 记住这些类就可以了，这些都是`Number`的子类。

**包装类**

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

**自动封箱/自动装箱**

底层默认调用`valueOf`方法进行封箱

**自动拆箱**

用`***Value()`进行拆箱

> 自动封装，将基本类型的变量赋值给对应的引用类型对象  
> 自动拆箱，将引用类型的变量赋值给对应的基本类型变量

public class Test{
     public static void main(String[] args){
      int i = 5;
      Integer integer = new Integer(i);//装箱
      //拆箱
      int i2 = integer.intValue();
     }
    }
    //
    public class Test{
     public static void main(String[] args){
      int i = 5;
      Integer integer = new Integer(i);
      Interger i2 = i;//自动装箱
      int i3 = integer;//自动拆箱
     }
    }
    //
    public class Test{
     public static void main(String[] args){
      char c = 'Vic';
      character c2 = c;
      c3 = c2;
      }
    }

## 4. 类Date ##

`Date`代表日期的类

#### Date的构造方法 ####

**Date():** 为分配Date对象，并初始化对象  
`Date(int year, int month, int date)`

#### 类 Calendar日历的类 ####

`Calendar` 类是一个抽象类

public abstract class Calendar extends Object //Calendar 提供了一个类方法 getInstance Calendar rightNow = Calendar.getInstance();

## 结语 ##

*  下面我将继续对`Java`、 `Android`中的其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[1240]: /images/20210724/caff71b7e81b4c1b8ebafe3913140eb4.png
[Java]: https://www.jianshu.com/p/e6ac41a16226