Java基础（万字长文）

　　前言
　　本章节主要讲述java的一些基础语法，比如常见的数据类型，流程控制语句，类的一些属性和方法，帮助大家理解和快速入门。如果你已经对jav很熟悉了，可以跳过本章节的内容。  java简单介绍
　　Java是一门 面向对象  编程语言, Javas是静态语言。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。
　　这里简单说一下什么是静态语言，什么是动态语言？  静态语言,比如java它需要编译成机器码，才能够被计算识别可运行，因为计算机只能看懂二进制。  动态语言，不需要我们手动去编译，它可以直接去运行我们的代码文件，比较典型的python,js这种脚本语言。
　　其实动态语言它本身内置了一个解释器，它通过解释器去完成我们的编译工作，所以我们感知不到。
　　所谓工欲善其事，必先利其器，选择好的开发工具，能提升我们的开发体验。建议大家使用 jetbrains的  idea  开发工具来开发java应用, 目前大部分开发者都会选择使用它，非常的方便， 后边我会出一篇文章专门来讲一下，如何配置我们的idea工具，使得它更加强大。 下载idea
　　进入官网后，直接点击  download  进行下载,浏览器会自动判断你的当前操作系统，选择 Ultimate版本 ,另一个版本是社区版，我们选择专业版。下载完成后点击安装。
　　默认它是一个纯英文的界面， 我们也可以通过安装汉化插件，点击  设置 -> 插件 -> 搜索（Chinese (Simplified)  Language Pack / 中文语言包）  进行安装即可， 重启后会看到中文界面了。 配置JDK
　　我们可以直接通过idea来下载jdk，也可以通过  官网  来下载, 这里我们使用idea来下载jdk, 官网下载现在好像要注册账号了，有点小麻烦。打开idea，点击新建项目, 我们选择maven来新建项目, maven  是java的一种包管理工具，能够很方便的帮助我们构建项目，我们开发项目可能会引用一些成熟的第三方库，这时候我们就可以用简单的配置就可以把库引进来，想了解更多，可以到它的 官网  。选择好了以后，跟着以下步骤来搭建我们的环境: 点击项目sdk， 这时候会发现是空的  点击下载jdk, 版本我们选择1.8, 供应商我们选择  亚马逊 Corretto , 位置我们可以默认。下载好了以后，会自动帮我们选择刚刚下载的jdk 点击下一步， 项目名和项目所在位置可以自定义， 好了以后点击完成，会自动打开项目  目录结构说明pom.xml  这个文件存在于根目录， 主要用于配置maven的构建信息，学习基础部分，我们可以暂时不用管它。 src  这个目录主要用于放我们编写的源码，下边有一个java 和 resource 的目录，java存放我们的代码，resource主要放一些资源，比如配置文件这些，暂时可以不用管它。
　　为了规范，这些目录和文件不要去重命名或者其它更改， 如果改动， idea已经足够智能提醒我们不要乱改命名。  JDK是什么？
　　jdk（Java Development Kit） ，从字面意思翻译过来就是java开发的工具。打个比喻，我们打游戏之前需要安装一个软件，然后我们才能打开和操作它。那么jdk你也可以理解是一个软件，它用来帮助我们编写代码。这里还好引申另外两个名词， JRE和JVM。
　　JRE  顾名思义是java运行时环境，包含了java虚拟机，java基础类库。是使用java语言编写的程序运行所需要的软件环境，是提供给想运行java程序的用户使用的。JDK包含了JRE，同时还包含了编译java源码的编译器javac。JRE根据不同操作系统, 提供不同的运行时环境，所以java它也是跨平台的语言。
　　JVM是Java Virtual Machine(Java虚拟机)  的缩写。它是java运行环境的一部分，是一个虚构出来的计算机，它是通过在实际的计算机上仿真模拟各种计算机功能来实现的。JVM是用来解析和运行Java程序的。 hello world
　　我想要输出一句 ＂你好， 憨憨＂， 怎么搞? 这就安排。 首先在java目录新建一个文件，一个程序要跑起来，首先要有入口， 这个入口就是一个main方法，在java中，需要写在类中：  public class BaseMain {    public static void main(String[] args) {       System.out.println(＂你好， 憨憨＂);    } }
　　点击绿色的箭头就可以运行了，因为idea已经帮我们把环境基础起来了，所以直接run
　　为了后续方便调试，我们常会在控制台输出信息，所以在新建一个Log类：  public class Log {     public static void info(Object s) {         System.out.println(s);     } }
　　然后修改我们的main方法, static修饰的方法可以直接 类名 + 方法名去调用:  public class BaseMain {    public static void main(String[] args) {       Log.info(＂你好， 憨憨＂);    } }
　　好了,你学废了吗？
　　基本数据类型
　　数据类型，顾名思义就是数据的类型，什么是数据？举个例子，你在使用网站时，密密麻麻的文字和图片就是数据，而他们的载体，比如文字它就是字符类型，我们通常叫它为字符串，我们看到的视频，图片这种二进制数据，通常是byte类型。我们通过各种类型的数据在一起计算交互，最终实现我们的程序。
　　java有  8  种数据类型,分别是: boolean (1/8个字节1位)  char (2个字节16位)  byte (1个字节8位)  short (2个字节16位)  int (4个字节32位)  long (8个字节64位)  float (4个字节32位)  double (8个字节64位)
　　float 与 double:   // float a = 1.1; 1.1是字面量 这样会使得向下转型，会丢失精度  // 正确的写法： float a = 1.1f; double b = 1.1;
　　隐式转换:   short c = 1;   // 1是int型  精度比short高 没发隐式的向下转型成short    // 这样可以达到隐式转换的目的   c ++; // c = (short) (c + 1); 流程控制
　　我们说话的时候会有逻辑语句，程序也一样，有了它，就能控制程序在设定中运行，举个例子， ＂如果我教你写java, 你就做我女朋友＂
　　在java中用  if  表示： // 这里的true是boolean类型， 在数学中叫真,相反的是 false if(true) {   Log.info(＂做我女朋友＂); }
　　如果她拒绝了咋办? 并对你说了句 ＂go out !＂, 在java中用  else  表示否则的意思，类似转折语句: if(true) {   Log.info(＂做我女朋友＂); }else {   Log.info(＂滚＂); }
　　你还不想放弃，我在外加请你吃饭+看电影, 在java中我们可以用  else if  这么表示, 类似二次转折： // 第1层判断 if(教你写代码) {   Log.info(＂做我女朋友＂);   // 第2层判断 }else if(吃饭) {   Log.info(＂做我女朋友＂);   // 第3层判断 }else if(看电影) {   Log.info(＂做我女朋友＂); }else {   // 第4层判断   Log.info(＂滚＂); }
　　在你的不断努力下，她终于答应跟你吃饭了，这时候你要开始想了一下预算，那么预算可能会有很多种。在java中使用 switch来进行多种判断，为啥不是if，if也可以，但是多起来会导致if多层嵌套，不利于代码维护。说不定你下次改bug你都不知道写了啥。
　　当然也不完全是  switch  我们可以拆分方法，类等等。这里为了熟悉语法:
　　支持的判断类型 ： 需要 char、byte、short、int、Character、Byte、Short、Integer、String 或枚举 不支持: long、float、double  // 假设cost 为int型， 意思是花费 switch(cost) {   case 200:     Log.ingo(＂吃肯德基＂);     // break 意思是跳出循环      break;   case 100:     Log.ingo(＂汉堡王＂);     break;     // default： 当以上条件不满足的时候会默认执行这个语句   default:     Log.ingo(＂吃煎饼果子＂);     break; }
　　还是刚刚的例子， 吃完饭后，准备看电影，女神说了到10点，看没看完都回家，这时候你一直盯着看时间，生怕时间到了，中途你还上了个厕所, 忘了数数了。实际上这是一种循环的场景，一直在检测某一环节下满足某种条件时，执行对应的任务,在java中我们通常用  while  来表示,while类似当...什么时候。 # 没到十点 会一直执行 while(没到十点) {   // 配合if 实现， 跳出循环   if(十点到了) {      break;   }    // 上厕所 忘了看时间了   if(上厕所) {     // continue 表示跳出当前这个时刻，但不会终止循环, 下一次还是接着数数     continue;   }    Log.info(＂还剩.xx.分钟＂) }
　　然后时间到了，你们一起走在回家的路上，心想，出都出来了，至少拉一次手， 最终成功了。这种场景属于。这种场景属于，不管失败与否，事件都会执行一次，在Java中用  do ... while : do {   Log.info(＂拉手) } while(false)
　　最终女神跟你说了句：＂你是好人＂，你听了之后感动的哭了。
　　多喝热水  包装类型
　　前方高能， 如果你是小白，可能看的会有点糊涂 ~
　　基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成, 这里介绍常用的包装类型, 他们属于引用类型，因为他们本身也是一个对象  类  Integer
　　通常用于整数形，举个例子:   Integer x = 2;     // 装箱 调用了 Integer.valueOf(2)  int y = x;         // 拆箱 调用了 X.intValue()
　　Integer内部有一个缓冲池，缓冲池可以有效的帮我们缓存对象，从而减少对象的频繁创建, Java 8 中，Integer 缓存池的大小默认为  -128~127  我们可以通过源码可以看到:  // range [-128, 127] must be interned (JLS7 5.1.7)  assert IntegerCache.high >= 127;
　　其中  java new Integer(123)  相当于新建一个对象, 当我们再调用 java Integer.valueOf(123)  引用的就是同一个对象 。此外, Integer  不可被继承， 因为它的类是final修饰的。
　　valueOf()  方法的实现， 先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容， 对应的源码如下: public static Integer valueOf(int i) {     if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)         return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];     return new Integer(i); }
　　看到这里， 通过一个例子来感受一下:    Integer a = new Integer(123);   Integer b = Integer.valueOf(＂123＂);   Integer c = Integer.valueOf(123);    System.err.println(a == b); // false   System.err.println(a == c); // false   System.err.println(c == b); // true    // 自动装箱, 编译器会自动调用 valueOf   Integer d = 123;   Integer e = 124;   Integer f = 123;   System.err.println(d == e); // false 因为值不一样   System.err.println(f == d); // true
　　我们说默认的缓冲池大小为  -128~127  ，那么如果超过了怎么办。从源码看，内部会根据传进去的 i 进行 动态扩容  // 源码部分: private static class IntegerCache {  static final int low = -128;  static final int high;  static final Integer cache[];   static {    // high value may be configured by property    int h = 127;    String integerCacheHighPropValue =     sun.misc.VM.getSavedProperty(＂java.lang.Integer.IntegerCache.high＂);    if (integerCacheHighPropValue != null) {        try {            int i = parseInt(integerCacheHighPropValue);            i = Math.max(i, 127);            // Maximum array size is Integer.MAX_VALUE            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);        } catch( NumberFormatException nfe) {            // If the property cannot be parsed into an int, ignore it.        }    }    high = h;     cache = new Integer[(high - low) + 1];    int j = low;    for(int k = 0; k < cache.length; k++)        cache[k] = new Integer(j++);     // range [-128, 127] must be interned (JLS7 5.1.7)    assert Integer.IntegerCache.high >= 127;  }   private IntegerCache() {} }  String
　　该类型通常用于表示字符串对象, 和Integer一样，它也是final修饰的不可继承， 源码定义如下:   public final class String     implements java.io.Serializable, Comparable, CharSequence {     // java8: 使用char数组     private final char value[];      // 使用final修饰的数组 可以保证 String 不可变     // java 9     private final byte[] value;   }
　　我们可以看到初始值char数组是用finnal稀释的,这样保证  String对象  不可变的好处是什么？ 可以作为 hash的 key, 可以让hash值也不可变, 只需进行一次计算， 可以防止key重复， 在map取值的时候 会通过计算，hashCode() 和 equals来判断key, 而String的hashCode是根据 char[]数组内容来计算得到的散列码，如果相同的内容下，那么key是不可变的  String的缓存池， 如果一个String被创建过了， 再次获取可以从缓存池中获取，如果String可变的话 就没法使用缓存池了  安全性。 String常用做参数  天生线程安全 因为它不可变
　　String, StringBuffer and StringBuilder 三者联系？我们通过以下几点进行比较:  可变性:  String 不可变 (不可变只的是本身不可变， 本质上它的操作都会产生新的Object)StringBuffer and StringBuilder 可变 ( 并不会产生新的Object ,利用的是缓存池)  线程安全:  String（通过finnal）, StringBuffer(通过 synchronized进行同步 )StringBuilder 不是线程安全的  使用场景:  String 适合不需要频繁修改字符串StringBuilder 优先使用，频繁修改字符串时在考虑多线程共享变量时使用 StringBuffer  继承关系:  StringBuffer,StringBuilder 都继承了 AbstractStringBuilderStringBuffer,StringBuilder，String 都不可被继承
　　我们说  Integer  有缓冲池，那么String是不是也有呢？答案是有的。我们通常叫它 常量池  。
　　在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中，这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误， 不懂啥代的可以先放放，这属于jvm的环节，后边会给大家介绍。
　　String.intern()  方法: 如果字符串常量池包含了这个String对象，则直接返回该对象， 否则重新生成对象， 并返回, 举个例子：   StringBuilder a = new StringBuilder(＂hello＂);   StringBuilder b = new StringBuilder(＂hello＂);   StringBuilder c = a.append(＂＂);    System.out.println(a == b); // false 两个new 不同对象   System.out.println(a == c); // true append操作同一个对象    String x = a.toString().intern();   String y = b.toString().intern();   Log.info(＂x ----- y＂);   Log.info(x == y); // true   // 原因:   // String.intern 操作会把 a 字符串放到String pool 并返回字符串的引用   // b.intern操作 会去String pool中获取 发现字符串一样，所以直接返回 a的引用    String z = ＂hello＂;   String m = ＂hello＂;   Log.info(x == y); // true   // 直接使用字面量创建时， 会自动加入 String Pool中
　　这里引申一个面试题， 答案直接贴给大家:   String java = new StringBuilder(＂ja＂).append(＂va＂).toString();   Log.info(java); // java   Log.info(java == java.intern()); // true     String go = new StringBuilder(＂g＂).append(＂o＂).toString();   Log.info(go); // go   Log.info(go == go.intern()); // true    String java1 = new StringBuilder(＂ja＂).append(＂va＂).toString();   Log.info(java1);   // java   Log.info(java1 == java1.intern());  // false
　　上述string builder ,进行类加载后, 调用的时候内部默认会生成一个java的String 对象（java jdk 自身的原因, sum.misc.Version 类注入常量池 ）
　　关于 new String
　　这种方式创建字符串会获得两个对象,  编译时期 存在String Pool 指向 String的字面量  存在堆中的 String对象
　　以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容, 而是都会指向同一个 value 数组。  private final char value[];   public String(String original) {       this.value = original.value;       this.hash = original.hash;   }
　　没关系，代码能跑就行 ~  面向对象
　　面向对象  是一种编程思想，不仅仅在java，其它语言可以，通过这种方法轮，我们可以编写利于维护的代码，让我们的代码更加条理，更加的有艺术，有了它，后来又引入了 java设计模式 , 它也是一种编程方法， 可以把它理解为语文中的写作方法。 面向对象和面向过程?
　　网上介绍的也很多，但是介绍的有点复杂， 这里给大家提炼几个关键字:
　　面向对象 : 谁做了某件事 （主体对象是谁）
　　面向过程: 做了谁的某件事 （没有主体对象，一股劲的做）  类和方法
　　在java中，我们用类来实现面向对象，我们用java描述一个苹果对象:  class Apple {   Sting color; }
　　上面定义了一个Apple类，内部有一个color的属性，如果我们一开始想要红色的苹果，在java中可以使用构造函数：  class Apple {   Sting color;      // 完成初始化   Apple(String color) {       this.color = color;   }    }
　　想后期改颜色怎么办, 我们可以使用类的方法:  class Apple {   Sting color;      // 完成初始化   Apple(String color) {       this.color = color;   }   // 方法  // void指定的是返回值的类型， 用void表示无返回值   public void setColor(String color) {       this.color = color;   } }
　　如果想用两个颜色怎么办, 我们可以利用方法的重载, 在声明一个方法:
　　重载: 存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
　　重写： @Override 存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。  class Apple {   Sting color;      // 完成初始化   Apple(String color) {       this.color = color;   }   // 方法1   public void setColor(String color) {       this.color = color;   }  // 方法2   public void setColor(String color, String color) {       this.color = color;   } }
　　好了有了类， 如何使用它?首先要实例化:  // 实例 Apple apple = new Apple(＂red＂); // 调用实例方法 apple.setColor(＂green＂); 类的继承
　　继承顾名思义，继承类的一些属性和方法，举个例子， 还是刚刚的水果。java中使用  extends  :  // 水果类 class Furit {   Sting color;      // 完成初始化   Apple(String color) {       this.color = color;   }    public void setColor(String color) {       this.color = color;   } }   // 苹果类， 继承水果类 class Apple extends Furit {   // .... }   // 橘子类， 继承水果类 class Orange extends Furit {   // .... }   方法重写
　　使用 @Override 来重写方法  class Orange extends Furit {    @Override   public void setColor(String color) {       this.color = color;   } } 接口可以看成是完全的抽象类， java8之前 不能有方法实现， java8之后可以实现， 为了减少维护成本  接口内部的成员 默认都是public， 并且不允许定义为 private 和 protected java9之后允许定义private  接口的字段默认都是final 和 static 的  实现接口的方法通过 implements 关键字  接口直接也可以继承
　　接口的好处: 一个类可以实现多个接口， 但是不能继承多个抽象类, 接口主要用于约束类的一些行为，举个例子:  public interface Food {   void eat();  }   public class User implements Food {    // 必须实现接口的方法，不然会报错   public void eat() {    } }
　　接口之间也有继承:  public interface Food {   void eat();  }  public interface Food extends Food {}  类中的关键词
　　在之前的介绍中经常会看到 public ,static之类的，现在我们就一一介绍它：  final
　　修饰变量时:  作为常量， 可以是运行时常量也可使编译时常量， 不可改变  作为引用对象，不可以修改引用， 但可以修改本身的值
　　修饰方法时:  不能够被重写, 其中private是隐式的final
　　修饰类时:  不能够被继承  static
　　修饰变量：  所有实例共享静态变量 ，在内存中只存一份， 可以通过 class.name 访问  实例变量，每创建一个实例就会产生一个实例变量，与实例共存亡
　　静态方法:  静态方法在类加载的时候就存在了，不依赖任何实例， 必须有实现 不能是抽象方法  内部方法访问时 只可以访问static修饰的变量和方法，不能有this super关键字
　　静态语句块:  在类加载的时候值只运行一次  static {     //.... }
　　静态内部类: （static 不能修饰外部类）  静态内部类不能访问外部类非静态成员  创建不需要依赖外部类的实例化  public class OuterClass {    class InnerClass {       int x;   }    public String get() {       return InnerClass.x;  // 可以直接访问内部类的成员   }    static class StaticInnerClass {   }    public static void main(String[] args) {       // InnerClass innerClass = new InnerClass(); // ＂OuterClass.this＂ cannot be referenced from a static context       OuterClass outerClass = new OuterClass();       InnerClass innerClass = outerClass.new InnerClass();       StaticInnerClass staticInnerClass = new StaticInnerClass();   } }
　　静态导包：在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。  import static com.xxx.ClassName.* private
　　这个主要用于修饰私有属性和方法, 只能在本类中访问  public
　　公开权限, 表明该成员变量和方法是共有的，能在任何情况下被访问  protected
　　必须在同一包中才能被访问  类的初始化顺序
　　静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。
　　存在继承的情况下，初始化顺序为： 父优子 静优实  父类（静态变量、静态语句块）  子类（静态变量、静态语句块）  父类（实例变量、普通语句块）  父类（构造函数）  子类（实例变量、普通语句块）  子类（构造函数）  对象的通用方法//    public native int hashCode() // //    public boolean equals(Object obj) // //    protected native Object clone() throws CloneNotSupportedException // //    public String toString() // //    public final native Class<?> getClass() // //    protected void finalize() throws Throwable {} // //    public final native void notify() // //    public final native void notifyAll() // //    public final native void wait(long timeout) throws InterruptedException // //    public final void wait(long timeout, int nanos) throws InterruptedException // //    public final void wait() throws InterruptedException
　　我们介绍常用的几个:  equals 用于判断等价关系任何非null的对象与null 比较都为 false  基本类型： == 判断值 , 没有equals方法  引用类型: == 判断两个变量是否引用同一个对象 , equals判断引用的对象是否等价   public static void main() {     Log.info(＂1＂.equals(1)); // false     Log.info(＂--------->＂); // false      Integer a = 1;     Integer b = 1;     Integer c = new Integer(1);      Log.info(a.equals(b)); // true 1 == 1     Log.info(a == b); // true  引用的是同一个对象, 原因是Integer缓冲池      Log.info(a == c); // false new 关键词生成的新对象所以引用不同     Log.info(a.equals(c)); // true  他们引用的对象值都是1 所以相等 }
　　手动实现一个equals,在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象哈希值也相等  判断是否引用同一个对象 是 -> true  判断类型： null -> false 类型不同 -> false  判断值是否相同: 不同 -> false   @Override public int hashCode() {     int result = 17;     result = 31 * result + x;     result = 31 * result + y;     result = 31 * result + z;     return result; }  @Override public boolean equals(Object o) {     if (this == o) return true;     if (o == null || getClass() != o.getClass()) return false;      ObjectMain that = (ObjectMain) o;      if (x != that.x) return false;     if (y != that.y) return false;     return z == that.z; }  toString()
　　默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示  static {   Log.info(＂1＂.toString()); } clone
　　不推荐使用 clone方法来实现对象的拷贝, 建议使用拷贝构造函数或者工厂模式  浅拷贝： 引用的同一个对象  深拷贝： 引用的对象不同  public static void main(String[] args) {     // 拷贝的实现     CloneExample a = new CloneExample();     CloneExample b = new CloneExample(a);     a.set(＂c＂);     Log.info(b.get()); // a 说明是两个不同的对象 }  class CloneExample {     private String a;      CloneExample() {         this.a = ＂a＂;     }      CloneExample(CloneExample e) {         this.a = e.a;     }      public void set(String n) {         this.a = n;     }      public String get() {         return this.a;     } }  抽象类不能实例化 只能继承  如果一个类中存在抽象方法那么 这个类必须是抽象类, 定义抽象方法不要实现  abstract class Cat {     public abstract void getName(); }  class Animal extends Cat {      // 必须实现方法     @Override     public void getName() {      } } 异常类 Exception
　　Error:  虚拟机报错 VirtualMachineError  StackOverFlowError  OutOfMemoryError  AWTError
　　Exception:  IOException  EOFException  ...
　　RuntimeException  异常捕获
　　java中使用  try catch  捕获异常, finally 用于程序恢复  public static int main() {     int a = 0;      try {         a = 1;         throw new Exception(＂报错了＂);         // 在没有异常的情况下 ，返回值等于 try内部的返回值         // return a;     } catch (Exception e) {         Log.info(e.getMessage());         a = 2;         return a;     } finally {         a = 3;         Log.info(＂final＂);     //    return a;     }      //return a; }
　　好了，宝儿，我觉得你学会了
　　不要你觉得