JavaSE常见基础笔记

秒速五厘米 2022-02-23 16:25 220阅读 0赞

#### 一、Object类 ####

java.lang.Object，Object类是所有类的父类

<table> 
 <thead> 
  <tr> 
   <th>Method</th> 
   <th>Description</th> 
   <th>Modifier and Type</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>toString()</code></td> 
   <td>返回当前对象的字符串表达形式</td> 
   <td>String</td> 
  </tr> 
  <tr> 
   <td><code>equals(object)</code></td> 
   <td>用于判断两个对象的内容是否相同</td> 
   <td>boolean</td> 
  </tr> 
  <tr> 
   <td><code>clone()</code></td> 
   <td>创建并返回此对象的副本</td> 
   <td>protected Object</td> 
  </tr> 
  <tr> 
   <td><code>hashCode()</code></td> 
   <td>返回对象的哈希码值</td> 
   <td>int</td> 
  </tr> 
  <tr> 
   <td><code>getClass()</code></td> 
   <td>返回此object的运行时类</td> 
   <td>类&lt;?&gt;</td> 
  </tr> 
  <tr> 
   <td><code>notify()</code></td> 
   <td>唤醒正在等待对象监视器的单个线程</td> 
   <td>void</td> 
  </tr> 
  <tr> 
   <td><code>notifyAll()</code></td> 
   <td>唤醒正在等待对象监视器的所有线程</td> 
   <td>void</td> 
  </tr> 
  <tr> 
   <td><code>wait() / wait(long timeout)</code></td> 
   <td>导致当前线程等待</td> 
   <td>void</td> 
  </tr> 
  <tr> 
   <td><code>finalize()</code></td> 
   <td>当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象</td> 
   <td>protected void</td> 
  </tr> 
 </tbody> 
</table>

注：`finalize()` 不是开发人员主动调用的方法，而是由虚拟机JVM调用的。

#### 二、四种访问修饰符 ####

**作用范围：**

<table> 
 <thead> 
  <tr> 
   <th>访问修饰符\作用范围</th> 
   <th>同一类</th> 
   <th>同一包内其他类</th> 
   <th>其他包内子类</th> 
   <th>其他包内非子类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>private</td> 
   <td>可以被访问</td> 
   <td>不可以被访问</td> 
   <td>不可以被访问</td> 
   <td>不可以被访问</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>可以被访问</td> 
   <td>可以被访问</td> 
   <td>不可以被访问</td> 
   <td>不可以被访问</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>可以被访问</td> 
   <td>可以被访问</td> 
   <td>可以被访问</td> 
   <td>不可以被访问</td> 
  </tr> 
  <tr> 
   <td>public</td> 
   <td>可以被访问</td> 
   <td>可以被访问</td> 
   <td>可以被访问</td> 
   <td>可以被访问</td> 
  </tr> 
 </tbody> 
</table>

*  **私有权限（private）**  
    private可以修饰数据成员、构造方法及方法成员，不可以修饰类。被他修饰的成员，只能在定义他们的类中使用，在其他类中不能使用；
 *  **默认权限（default）**  
    类、方法、成员都可以使用默认权限，即不被private、protected，public修饰。默认权限同包权限，同包权限下的元素只能在定义它们的类中以及同包的类中被调用；
 *  **受保护权限（protected）**  
    protected可以修饰数据成员、构造方法和方法成员，不可以修饰类。被protected修饰的成员能在它们的类中以及同包的类中被调用。如果有不同包的类想要调用它们，那这个类必须是他的子类；
 *  **公共权限（public）**  
    public可以修饰类、数据成员、构造方法及方法成员。被public修饰的成员，可以在任何一个类中被调用，不管同包或者不同包。另外，类要想被其他包导入，必须声明为public，且被public修饰的类，类名必须与文件名相同。

#### 三、八种基本类型及包装类 ####

8种基本类型，类初始化时JVM会给其成员变量初始化（成员变量用基本类型修饰）：  
![8种基本类型][8]

8种包装类型，类初始化时JVM会给其成员变量初始化为NULL（用包装类型修饰）：  
![8种包装类型][8 1]  
阿里代码规范，实体POJO类最好使用包装类：  
![阿里代码规范][format_png]  
补充：定义局部变量时必须手动初始化，不然会报错。

#### 四、break　continue　return ####

**1. break**  
　　用来终止循环，继续执行循环后面代码

for (int i = 0; i <= 5; i++) { 
    	if (i == 3)
    		break;
    	System.out.print("a" + i +" ");
    }
    System.out.println("end");
    
    控制台结果:  a0 a1 a2 end

**2. if continue**  
　　用来跳过当前循环，当 if 中条件满足时，不再执行循环体后面的代码，而是重新开始循环

for (int i = 0; i <= 5; i++) { 
    	if (i == 3)
    		continue;
    	System.out.print("a" + i +" ");
    }
    System.out.println("end");
    
    控制台输出: a0 a1 a2 a4 a5 end

**3. return**  
　　用来结束函数执行，不再执行后面所有代码，在一个函数内任意位置调用return，直接退出函数

for (int i = 0; i <= 5; i++) { 
    	if (i == 3)
    		return;
    	System.out.print("a" + i +" ");
    }
    System.out.println("end");
    
    控制台输出: a0 a1 a2

总结：

*  如果存在多层循环，使用break只能跳出一层循环；
 *  使用continu用来结束此次循环并重新开始下一次循环；
 *  不管存在几层循环，使用return结束函数执行，立即跳出；
 *  在Java8 lambda forEach中，使用return只能结束此次循环，继续执行下一次循环。

#### 五、Java中泛型 ####

在使用 Object 来实现通用、不同类型的处理，有这么两个缺点：

*  每次使用时都需要强制转换成想要的类型
 *  在编译时编译器并不知道类型转换是否正常，运行时才知道，不安全

泛型的作用，意味着编写的代码可以被不同类型的对象所重用。为什么引入泛型？最引人注意的一个原因，就是为了创建容器类。

实际上引入泛型的主要目标有以下几点，  
类型安全：

*  泛型的主要目标是提高 Java 程序的类型安全；
 *  编译时期就可以检查出因 Java 类型不正确导致的 ClassCastException 异常；
 *  符合越早出错代价越小原则。

消除强制类型转换：

*  泛型的一个附带好处是，使用时直接得到目标类型，消除许多强制类型转换；
 *  所得即所需，这使得代码更加可读，并且减少了出错机会。

潜在的性能收益：

*  由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改；
 *  所有工作都在编译器中完成；
 *  编译器生成的代码跟不使用泛型（和强制类型转换）时所写的代码几乎一致，只是更能确保类型安全而已。

**1. 泛型类**

定义：

public class ClassName<T> { 
    
        private T t;
    
        public T getT() {  return t; }
    
        public void setT(T t) {  this.t = t; }
    }

使用：

public static void main(String[] args) { 
    
        ClassName<String> className1 = new ClassName<>();
        className1.setT("java");
        System.out.println(className1.getT());
    
        ClassName<Integer> className2 = new ClassName<>();
        className2.setT(123);
        System.out.println(className2.getT());
    }

**2. 多泛型类**

多泛型类定义：

/** * 泛型类 * * @param <T>泛型T * @param <V>泛型V */
    public class Fun<T, V> { 
        private T data;
        private V data2;
    
        //泛型方法
        public T getData() {  return data; }
        public void setData(T data) {  this.data = data; }
    
        public V getData2() {  return data2; }
        public void setData2(V data2) {  this.data2 = data2; }
    }

存放无数个：`Fun<T,T1,T2,T3,.,.>{ ... }`

泛型规范：

*  `E` — Element，常用在java Collection里，如：`List<E>,Iterator<E>,Set<E>`；
 *  `K,V` — Key，Value，代表Map的键值对；
 *  `N` — Number，数字；
 *  `T` — Type，类型，如String，Integer等等。

**3. 泛型方法**

定义：

public class ClassName<T> { 
    
        private T t;
    
        public T getT() {  return t; }
    
        public void setT(T t) {  this.t = t; }
    
    	public static <T> void printClassName(T t) { 
        	System.out.println("获取传入对象类型" + t.getClass().getName());
    	}
    }

使用：

public static void main(String[] args) { 
    
        ClassName.printClassName(1.0f);
        ClassName.printClassName(1);
        ClassName.printClassName("I'm String");
        ClassName.printClassName(new ArrayList<String>());
    }

运行结果：

java.lang.Float
    java.lang.Integer
    java.lang.String
    java.util.ArrayList

**4. 泛型接口**

接口定义：

public interface InterfaceName<T> { 
    
    	public void methodName(T t);
    }

实现方式：

public class InterfaceImpl<T> implements InterfaceName<T> { 
    
        @Override
        public void methodName(T t) { 
            System.out.println(t.getClass().getName());
        }
    }

使用：

public static void main(String[] args) { 
    
        InterfaceImpl<String> interfaceImplName = new InterfaceImpl<String>();
        interfaceImplName.methodName("泛型测试接口");
    }

**5. 泛型通配符**

泛型通配符有三种：

*  `<?>` 任意通配符
 *  `<? extends E>` 确定上限，E及其子类
 *  `<? super E>` 确定下限，E及其父类

确定上限：接收的引用类型要么是Person类，要么是Person的子类

//确定上限
    public class ClassName1<? extends Person> { 
    	...
    }

确定下限：接收的引用类型要么是man类，要么是man的父类

public class ClassName2<? super man> { 
    	...
    }

**6. 参考**

*  [面试旧敌之 Java 泛型 ：主要概念及特点][Java _]

[8]: /images/20220223/82dbb62d514e46e0af6e8cc4c0a8f1ba.png
[8 1]: /images/20220223/42f1b4b1a91542fc910308c850fa2d9e.png
[format_png]: /images/20220223/534f21a0c9e3462cbad745f63b3d9b06.png
[Java _]: https://juejin.im/entry/584abdff61ff4b0058d50547