2-Java语法基础

说在前面的话

• 以下所有的文字，都是自己的理解，不代表正确性
• 基本语言统用的语法就不说了

Java程序结构

Hello world

/**
 * 可以用来自动创建文档的注释
 */
public class Hello {
    public static void main(String[] args) {
        // 向屏幕输出文本:
        System.out.println("Hello, world!");
        /* 多行注释开始
        注释内容
        注释结束 */
    }
} // class定义结束

多个函数

数据类型

就像很多其他的语言一样，java自身的特点并没有很多，因此，此处也不进行进一步的介绍

面向对象的JAVA

面向对象基础

此处，我们面临几个重点的问题，对于一个新手，通过快速的浏览整体需要掌握的内容，来建立自己的知识库基本上，包含如下几个核心问题

• 如何定义方法
• 继承
• 多态与抽象类
• 接口
• 静态字段/作用域/内部类
• 包和模块

学过C++的朋友，对于类的格式和定义的方式是比较清楚的，此处仅仅给出一个最快速入门的方法，几个核心的知识

方法

几个需要注意的点

• 函数定义
• 修饰词：public/protect/private
• 构造函数：初始化的对象必须要执行的函数，与类重名
• 重载函数：同名不同不同参数

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        if (age < 0 || age > 100) {
            throw new IllegalArgumentException("invalid age value");
        }
        this.age = age;
    }
}

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}

继承

有三种继承，关键词是extends

• public
• private
• protect
  例如：

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;

    public int getScore() { … }
    public void setScore(int score) { … }
}

class Person {
    protected String name;
    protected int age;
}

class Student extends Person {
    public String hello() {
        return "Hello, " + name; // OK!
    }
}

继承的几个要点：

• 所有的类都有一个最早的祖先，即object
• super=this 指代父亲，定位父类的参数
• 阻止继承 final 修饰，如：public final class Rect extends Shape
• 允许继承sealed， 如：public sealed class Shape permits Rect, Circle, Triangle {
  …
  }

多态与抽象类

所谓多态，即是重写父类的函数，运行期才能动态决定调用的子类方法

public class Main {
    public static void main(String[] args) {
    }
}

class Person {
    public void run() {}
}

public class Student extends Person {
    @Override // Compile error!
    public void run(String s) {}
}

抽象类的出现就是为了能够更好的实现多态的这个“功能”，如下所示的为抽象类和抽象方法：

abstract class Person {
    public abstract void run();
}

为什么我们需要抽象类，为了更好的多样性，层次和模块编程
几个需要注意的点：

• 如果定义成了抽象类的话，那么子类就必须要把定义成的抽象的函数都要实现
• 抽象类只能被继承

接口

经常会听到java 的工程师会说接口，interface，我想即是一个屏蔽一个模块内部功能后的所有的接口，用于其他模块的调用。
接口则是抽象类的进一步抽象化： 没有任何字段的抽象类，即可换成接口。

abstract class Person {
    public abstract void run();
    public abstract String getName();
}

因此，我们可以换一种写法：

interface Person {
    void run();
    String getName();
}

需要注意的点：

• 一个类只能有一个父类，但可以有多个接口
• class Student implements Person, Hello { // 实现了两个interface
  …
  }

几个核心 点如下：

///	abstract class	interface
继承	只能extends一个class	可以implements多个interface
字段	可以定义实例字段	不能定义实例字段
抽象方法	可以定义抽象方法	可以定义抽象方法
非抽象方法	可以定义非抽象方法	可以定义default方法

public class Main {
    public static void main(String[] args) {
        Person p = new Student("Xiao Ming");
        p.run();
    }
}

interface Person {
    String getName();
    default void run() {
        System.out.println(getName() + " run");
    }
}

class Student implements Person {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

静态字段/方法

用static 修饰的
需要注意几个点：

• 因为interface是一个纯抽象类，所以它不能定义实例字段。但是，interface是可以有静态字段的，并且静态字段必须为final类型：

public interface Person {
public static final int MALE = 1;
public static final int FEMALE = 2;
}

• 静态字段属于所有实例“共享”的字段，实际上是属于class的字段；

• 调用静态方法不需要实例，无法访问this，但可以访问静态字段和其他静态方法；

• 静态方法常用于工具类和辅助方法。

包

关键字：package
特点：在这里插入代码片他是一个目录
一个类一个文件

访问权限（作用域）

作用域	当前类	同一package	子孙类	其他package
public	√	√	√	√
protected	√	√	√	×
friendly	√	√	×	×
private	√	×	×	×

不写时默认为friendly ，也即是“包访问权限”。

内部类

显然内部类，即是定义在一个类的内部的类，依托于类使用

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer("Nested"); // 实例化一个Outer
        Outer.Inner inner = outer.new Inner(); // 实例化一个Inner
        inner.hello();
    }
}

class Outer {
    private String name;

    Outer(String name) {
        this.name = name;
    }

    class Inner {
        void hello() {
            System.out.println("Hello, " + Outer.this.name);
        }
    }
}

classpath和jar

classpath是JVM用到的一个环境变量，它用来指示JVM如何搜索class。
现在我们假设classpath是.;C:\work\project1\bin;C:\shared，当JVM在加载abc.xyz.Hello这个类时，会依次查找：

• <当前目录>\abc\xyz\Hello.class

• C:\work\project1\bin\abc\xyz\Hello.class

• C:\shared\abc\xyz\Hello.class

classpath的设定方法有两种：

• 在系统环境变量中设置classpath环境变量，不推荐；

• 在启动JVM时设置classpath变量，推荐。

我们强烈不推荐在系统环境变量中设置classpath，那样会污染整个系统环境。在启动JVM时设置classpath才是推荐的做法。实际上就是给java命令传入-classpath或-cp参数：

java -classpath .;C:\work\project1\bin;C:\shared abc.xyz.Hello
或者使用-cp的简写：

java -cp .;C:\work\project1\bin;C:\shared abc.xyz.Hello

jar 包的构成：
如果有很多.class文件，散落在各层目录中，肯定不便于管理。如果能把目录打一个包，变成一个文件，就方便多了。

jar包就是用来干这个事的，它可以把package组织的目录层级，以及各个目录下的所有文件（包括.class文件和其他文件）都打成一个jar文件，这样一来，无论是备份，还是发给客户，就简单多了。

jar包实际上就是一个zip格式的压缩文件，而jar包相当于目录。如果我们要执行一个jar包的class，就可以把jar包放到classpath中：

java -cp ./hello.jar abc.xyz.Hello