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;
}

好了，宝儿，我觉得你学会了

不要你觉得

展开阅读全文

页面更新：2024-04-28

标签：缓存字节语句女朋友对象类型语言代码基础程序方法

1 2 3 4 5