Java 基础知识

本文整合了 Java 开发的基础知识，涵盖了基础语法、数据类型、变量与修饰符、运算符以及流程控制等核心内容。

1. 简介

java简介

Java分为三个体系：

JavaSE(J2SE)(Java2 Platform Standard Edition，java平台标准版)

JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)

JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)

开发环境配置(windows下)

java下载

下载后安装，配置系统环境变量

此电脑 > 右键属性 > 高级 > 环境变量

变量名：JAVA_HOME
变量值：C:\Program Files (x86)\Java\jdk1.8.0_91        // 要根据自己的实际路径配置
变量名：CLASSPATH
变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;         //记得前面有个"."
变量名：Path
变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

windows10 变量值已有的上面点开，然后新建加到下方，以免破坏原有的环境变量

重启后生效

测试JDK是否安装成功

1. “开始”->”运行”，键入”cmd”；

2. 键入命令: java -version、java、javac 几个命令

---

2. java基础语法

hello world

HelloWorld.java (源文件名必须和类名相同)

public class HelloWorld {
   /* 第一个Java程序.
    * 它将打印字符串 Hello World
    */
    public static void main(String []args) {  // 主方法入口：所有的Java 程序由public static void main(String args[])方法开始执行
       System.out.println("Hello World"); // 打印 Hello World
    }
}

（cmd在java文件的同一路径下）

1. 编译 javac -encoding utf-8 HelloWorld.java (含中文最好使用 -encoding utf-8编译，以免出现错误)
2. 运行 java HelloWorld 打印 HelloWorld

类和对象

public class Puppy{  // Puppy 类  一个源文件中只能有一个public类
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name );
   }

   public void setAge( int age ){
       puppyAge = age;
   }

   public int getAge( ){
       System.out.println("Puppy's age is :" + puppyAge );
       return puppyAge;
   }

   public static void main(String []args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );  // 声明：声明一个对象，包括对象名称和对象类型 实例化：使用关键字new来创建一个对象 初始化：使用new创建对象时，会调用构造方法初始化对象
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

import

Employee.java

import java.io.*;  //下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
public class Employee{
   //salary是静态的私有变量
   private static double salary;
   // DEPARTMENT是一个常量
   public static final String DEPARTMENT = "Development ";
   public static void main(String args[]){
      salary = 1000;
      System.out.println(DEPARTMENT+"average salary:"+salary);
   }
}

EmployeeTest.java

import java.io.*;
public class EmployeeTest{

   public static void main(String args[]){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

这两段是从不同章节拼过来的：EmployeeTest 用到了 new Employee(String) 以及 empAge/empDesignation/empSalary/printEmployee 四个方法，而上面的 Employee 只有一个静态 salary 字段和 main，直接编译会有 5 处 cannot find symbol。按上面注释补全 Employee 之后才能编译运行

---

3. 基本数据类型

基本数据类型

两大数据类型：

1. 内置数据类型
2. 引用数据类型

内置数据类型

public class PrimitiveTypeTest {
    public static void main(String[] args) {
        // byte
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
        System.out.println("包装类：java.lang.Byte");
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println();
    // short
    System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
    System.out.println("包装类：java.lang.Short");
    System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
    System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
    System.out.println();

    // int
    System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
    System.out.println("包装类：java.lang.Integer");
    System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
    System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
    System.out.println();

    // long
    System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
    System.out.println("包装类：java.lang.Long");
    System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
    System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
    System.out.println();

    // float
    System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
    System.out.println("包装类：java.lang.Float");
    // 注意浮点的 MIN_VALUE 不是"最小值"而是**最小正非零值**（Float.MIN_VALUE=1.4E-45）；
    // float 的实际下界是 -Float.MAX_VALUE。整型的 MIN_VALUE 才是最负值。
    System.out.println("最小正值：Float.MIN_VALUE=" + Float.MIN_VALUE);
    System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
    System.out.println();

    // double
    System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
    System.out.println("包装类：java.lang.Double");
    // 同上，Double.MIN_VALUE=4.9E-324，下界是 -Double.MAX_VALUE
    System.out.println("最小正值：Double.MIN_VALUE=" + Double.MIN_VALUE);
    System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
    System.out.println();

    // char
    System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
    System.out.println("包装类：java.lang.Character");
    // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
    System.out.println("最小值：Character.MIN_VALUE="
            + (int) Character.MIN_VALUE);
    // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
    System.out.println("最大值：Character.MAX_VALUE="
            + (int) Character.MAX_VALUE);
}
}

上面这段把 7 种基本类型走了一遍，第 8 种 boolean 没法照同样的格式打印——原因本身就是个知识点：

System.out.println(Boolean.SIZE);        // 编译错误：Boolean 没有 SIZE 常量
System.out.println(Boolean.MIN_VALUE);   // 编译错误：也没有 MIN_VALUE / MAX_VALUE

Byte、Short、Integer、Long、Float、Double、Character 七个包装类都有 SIZE（以及 MIN_VALUE/MAX_VALUE），只有 Boolean 一个都没有。这不是遗漏，而是因为 JVM 规范并没有规定 boolean 占多少位：规范只说 boolean 在 JVM 内部用 int 表示（0 和 1），boolean[] 用 byte 数组表示；具体实现可以按 1 位、1 字节、4 字节存，取决于 JVM 和是否在数组里。既然宽度不确定，就给不出 SIZE。

Boolean 有的是另外两个常量：Boolean.TRUE 和 Boolean.FALSE。

char 那两行也值得多说一句：char 是无符号的 16 位类型，范围 0 ~ 65535，这是 Java 里唯一的无符号整型。正因为无符号，Character.MIN_VALUE 是 \u0000 而不是某个负数；而且它是”字符”类型，直接 println 会打印出对应的字符（MIN_VALUE 是不可见的 NUL），所以上面示例必须强转 (int) 才能看到数值——这个 (int) 不是可有可无的写法习惯。

引用数据类型

1. 引用类型变量由类的构造函数创建，可以使用它们访问所引用的对象。这些变量在声明时被指定为一个特定的类型，比如Employee、Pubby等。变量一旦声明后，类型就不能被改变了。
2. 对象、数组都是引用数据类型。
3. 所有引用类型的默认值都是null。
4. 一个引用变量可以用来引用与任何与之兼容的类型。
5. 例子：Animal animal = new Animal(“giraffe”）

常量

final double PI = 3.1415927;  //常量指不能改变的量,用final标志,通常用大写标识

int decimal = 100;   // 十进值
int octal = 0144;  // 8进值
int hexa =  0x64;  // 16进值

字符串

双引号

"Hello World"
"two\nlines"
"\"This is in quotes\""

char a = '\u0001';   // 变量a 的值为 '\u0001'
String a = "\u0001";

---

4. 变量类型

变量类型

在Java语言中

1. 局部变量
2. 实例变量
3. 类变量

所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

int a, b, c;         // 声明三个int型整数：a、b、c。
int d = 3, e, f = 5; // 声明三个整数并赋予初值。
byte z = 22;         // 声明并初始化z。
double pi = 3.14159; // 声明了pi。
char x = 'x';        // 变量x的值是字符'x'。

局部变量

public class Test{
   public void pupAge(){
      int age = 0;   // age是一个局部变量。定义在pupAge()方法中，它的作用域就限制在这个方法中
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]){
      Test test = new Test();
      test.pupAge();
   }
}

实例变量

import java.io.*;
public class Employee{
   // 这个成员变量对子类可见
   public String name;
   // 私有变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }
   // 打印信息
   public void printEmp(){
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]){
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

类变量

import java.io.*;
public class Employee{
   //salary是静态的私有变量
   private static double salary;
   // DEPARTMENT是一个常量
   public static final String DEPARTMENT = "Development ";
   public static void main(String args[]){
      salary = 1000;
      System.out.println(DEPARTMENT+"average salary:"+salary);
   }
}

// 如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT

---

5. 修饰符

Java修饰符

主要分为以下两类：

1. 访问修饰符
2. 非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端

public class className {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
   // 方法体
}

访问控制修饰符

默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为public。

String version = "1.5.1";
boolean processOrder() {
   return true;
}

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为private的方法、变量和构造方法只能被所属类访问。注意”类和接口不能声明为private”只对顶层类型成立：顶层类/接口只能是 public 或包级私有；而成员（嵌套）类和嵌套接口完全可以用 private，JDK 自己就大量这么写，比如 HashMap.Node 就是 private static class。

声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问。

Private访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

公有访问修饰符-public

被声明为public的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的public类分布在不同的包中，则需要导入相应public类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

public static void main(String[] arguments) {
   // ...
}

受保护的访问修饰符-protected

被声明为protected的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。

Protected访问修饰符不能修饰顶层类和接口（嵌套类、嵌套接口可以），方法和成员变量能够声明为protected，但是接口的成员变量和成员方法不能声明为protected。

子类能访问Protected修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

下面的父类使用了protected访问修饰符，子类重写（override）了父类的openSpeaker()方法——同名同参数列表是重写，重载指的是同一个类里参数列表不同的同名方法

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

// 必须 extends，否则两个类之间根本不存在父子关系，也就谈不上重写
class StreamingAudioPlayer extends AudioPlayer {
   // 访问级别不能收窄：这里去掉 protected 变成包级私有，
   // javac 会报 attempting to assign weaker access privileges
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

如果把openSpeaker()方法声明为private，那么除了AudioPlayer之外的类将不能访问该方法。如果把openSpeaker()声明为public，那么所有的类都能够访问该方法。如果我们只想让该方法对其所在类的子类可见，则将该方法声明为protected。

访问控制和继承

请注意以下方法继承的规则：

1. 父类中声明为public的方法在子类中也必须为public。
2. 父类中声明为protected的方法在子类中要么声明为protected，要么声明为public。不能声明为private。
3. 父类中声明为private的方法，不能够被继承。

这三条只覆盖了访问权限一个维度。重写（override）实际上有三条独立的约束，都可以用上面那个 AudioPlayer 例子跑出来验证——把 extends 补上之后编译一次，编译器会逐条告诉你：

一、访问权限只能放宽，不能收窄。

class AudioPlayer {
    protected boolean openSpeaker(Speaker sp) { return true; }
}
class StreamingAudioPlayer extends AudioPlayer {
    boolean openSpeaker(Speaker sp) { return true; }   // 包级私有，比 protected 窄
}
// error: openSpeaker(Speaker) in StreamingAudioPlayer cannot override
//        openSpeaker(Speaker) in AudioPlayer
//        attempting to assign weaker access privileges; was protected

改成 protected 或 public 都可以，改成 private 或不写修饰符就不行。原因是里氏替换：既然可以拿子类对象当父类用，父类能调的方法子类就必须也能调。

二、返回类型可以协变（covariant），但不能变宽。

class Animal { Animal reproduce() { ... } }
class Cat extends Animal {
    @Override Cat reproduce() { ... }     // 合法：Cat 是 Animal 的子类
}
// 反过来把 Cat.reproduce() 的返回类型写成 Object 就不行 —— 调用方按 Animal 接收会崩

这条从 Java 5 才开始支持，早期版本要求返回类型完全一致。

三、受检异常只能变窄，不能抛出更宽的。

class Base { void run() throws IOException { } }
class Sub extends Base {
    @Override void run() throws FileNotFoundException { }   // 合法：是 IOException 的子类
    // void run() throws Exception { }                      // 不合法：比 IOException 宽
    // void run() { }                                       // 合法：一个都不抛，最窄
}

注意这条只管受检异常，RuntimeException 及其子类不受约束，随便抛。

这三条本质是同一件事的三个面：子类必须能无条件替换父类——调用权限不能更严、拿到的返回值不能超出预期、需要处理的异常不能变多。记住这个原则就不用背规则了。加上 @Override 注解，上面三种错误都会在编译期就被拦下来，而不是等到运行时才发现调错了方法。

非访问修饰符

static : 用来创建类方法和类变量。

final : 用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract : 用来创建抽象类和抽象方法。

synchronized和volatile : 主要用于线程的编程。

static修饰符

1. 静态变量 ： 也被称为类变量。用来声明独立于对象的静态变量,局部变量不能被声明为static变量
2. 静态方法 ： 来声明独立于对象的静态方法

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }

   private static void addInstance() {
      numInstances++;
   }

   InstanceCounter() {
      InstanceCounter.addInstance();
   }

   public static void main(String[] arguments) {
      System.out.println("Starting with " + InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
      }
      System.out.println("Created " +       InstanceCounter.getCount() + " instances");
   }
}

final修饰符

final变量:

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

final方法:
类中的Final方法可以被子类继承，但是不能被子类修改。

声明final方法的主要目的是防止该方法的内容被修改

public class Test{
    public final void changeName(){
       // 方法体
    }
}

final类： 不能被继承

public final class Test {
   // 类体
}

---

6. 运算符

Java 运算符

主要分为一下几种

1. 算术运算符
2. 关系运算符
3. 位运算符
4. 逻辑运算符
5. 赋值运算符
6. 其他运算符

算术运算符

ArithmeticOperator.java

public class ArithmeticOperator {

    public static void main(String args[]) {
       int a = 10;
       int b = 20;
       int c = 25;
       int d = 25;
       System.out.println("a + b = " + (a + b) );
       System.out.println("a - b = " + (a - b) );
       System.out.println("a * b = " + (a * b) );
       System.out.println("b / a = " + (b / a) );
       System.out.println("b % a = " + (b % a) );
       System.out.println("c % a = " + (c % a) );
       System.out.println("a++   = " +  (a++) );
       System.out.println("a--   = " +  (a--) );
       // 查看  d++ 与 ++d 的不同
       System.out.println("d++   = " +  (d++) );  // 当前语句后 +1
       System.out.println("++d   = " +  (++d) );  // 当前语句前 +1
    }
  }

关系运算符

RelationalOperator.java

public class RelationalOperator {

   public static void main(String args[]) {
      int a = 10;
      int b = 20;
      System.out.println("a == b = " + (a == b) );
      System.out.println("a != b = " + (a != b) );
      System.out.println("a > b = " + (a > b) );
      System.out.println("a < b = " + (a < b) );
      System.out.println("b >= a = " + (b >= a) );
      System.out.println("b <= a = " + (b <= a) );
   }
}

逻辑运算符

LogicalOperators.java

public class LogicalOperators {
   public static void main(String args[]) {
      boolean a = true;
      boolean b = false;
      System.out.println("a && b = " + (a&&b));
      System.out.println("a || b = " + (a||b) );
      System.out.println("!(a && b) = " + !(a && b));
   }
 }

赋值运算符

AssignmentOperator.java

public class AssignmentOperator {
   public static void main(String args[]) {
      int a = 10;
      int b = 20;
      int c;
      c = a + b;
      System.out.println("c = a + b is " + (a + b));
      System.out.println("c += a  is " + (c+=a) );
      System.out.println("c -= a is " + (c -=a));
      System.out.println("c *= a is " + (c *= a));
      a = 10;
      c = 15;
      System.out.println("c /= a is " + (c/=a) );
      a = 10;
      c = 15;
      System.out.println("c %= a  is " + (c %= a));
   }
 }

条件运算符

ConditionalOperator.java

public class ConditionalOperator {
   public static void main(String args[]){
      int a , b;
      a = 10;
      b = (a == 1) ? 20: 30;   // 不成立
      System.out.println( "Value of b is : " +  b );  // 30
      b = (a == 10) ? 20: 30;    // 成立
      System.out.println( "Value of b is : " + b );  // 20
   }
}

instanceOf 运算符

Car.java

class Vehicle {}

public class Car extends Vehicle {  // Car 继承了Vehicle所有属性和方法
   public static void main(String args[]){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;   // 被比较的对象兼容于右侧类型,该运算符仍然返回true
      System.out.println( result);  // true
   }
}

---

7. 分支结构

if else

IfElse.java

public class Test {

   public static void main(String args[]){
      int x = 30;

      if( x == 10 ){
         System.out.print("Value of X is 10");
      }
      else if( x == 20 ){
         System.out.print("Value of X is 20");
      }
      else if( x == 30 ){
         System.out.print("Value of X is 30");
      }
      else{
         System.out.print("这是 else 语句");
      }
   }
}

嵌套的if…else语句

public class Test {

   public static void main(String args[]){
      int x = 30;
      int y = 10;

      if( x == 30 ){
         if( y == 10 ){
             System.out.print("X = 30 and Y = 10");
          }
       }
    }
}

switch语句

public class Test {

   public static void main(String args[]){
      //char grade = args[0].charAt(0);
      char grade = 'C';

      switch(grade)
      {
         case 'A' :
            System.out.println("优秀");
            break;
         case 'B' :
         case 'C' :
            System.out.println("良好");
            break;
         case 'D' :
            System.out.println("及格");
            // 注意这里故意没有 break —— 见下面说明
         case 'F' :
            System.out.println("你需要继续努力");
            break;
         default :
            System.out.println("无效等级");
      }
      System.out.println("你的等级是 " + grade);
   }
}

case 穿透（fall-through）

case 'D' 后面故意漏掉了 break，这是 switch 最经典的坑：匹配成功之后不会自动跳出，会一直往下执行到遇到 break 或者 switch 结束为止。

上面示例取 grade = 'C'，走的是 case 'C' 那条带 break 的分支，所以这个坑被掩盖了。把它改成 'D' 就能看出来：

char grade = 'D';
// 输出：
//   及格
//   你需要继续努力          ← 穿透到 case 'F' 了
//   你的等级是 D

穿透并不总是错的——上面 case 'B' 和 case 'C' 共用一段逻辑，正是故意利用穿透来合并分支（空 case 直接落到下一个）。所以判断标准是：空 case 落下去是惯用法，非空 case 落下去几乎总是漏写 break。

对比一下 Go 的选择：Go 的 switch 默认不穿透，每个 case 结束自动跳出，需要穿透时反过来显式写 fallthrough。

switch grade {
case 'B', 'C':                  // 想合并分支，直接写在一起，不靠穿透
    fmt.Println("良好")
case 'D':
    fmt.Println("及格")
    fallthrough                 // 要穿透必须显式声明
case 'F':
    fmt.Println("你需要继续努力")
}

两种设计的取舍很清楚：C/Java 那套让”合并分支”变得自然，代价是漏写 break 成了最高频的 bug 之一；Go 反过来把默认值设成安全的那一侧，代价是合并分支要换一种写法。Java 14 之后的 switch 表达式（case 'B', 'C' -> ...）实际上也走向了 Go 这一侧——箭头形式不穿透。

---