JavaSE

java语法

  • System.out.println(var)当参数为引用类型时, 自动转换为System.out.println(var.toString()). 其中System在java.lang中, 而System.out为System类的一个静态成员.

  • java中没有函数默认值机制

  • java成员函数的实现必须直接写在类体中

  • java.lang目录下的"顶级"类无需import可以直接使用

  • const与goto也是java关键字, 但目前没有具体含义(保留关键字). 注意, java中用final表示常量

  • java源代码位置

C:\Program Files\Java\jdk-14.0.1\lib\src\
# System包的位置
C:\Program Files\Java\jdk-14.0.1\lib\src\java.base\java\lang\System

java代码规范

违反如下规范不会报语法错误

命名规范

变量名, 方法名采用小写字母开头的驼峰式命名方法

常量名全部大写中间加下划线

类名, 接口名使用大写字母开头的驼峰式命名方法

源代码(.java)文件名与类名一致, 且一个文件里只放一个外部类, 可以是public或没有修饰符

包名(目录名)全部小写使用倒序的网址名加上项目名, 例如com.baidu.project1

注释规范

其他

  • IDEA中提示一个文件里只能有一个外部类(备注: matlab里强制一个文件里只能有一个方法, 否则直接报语法错误, 有异曲同工之处)

java程序的执行顺序与内存结构

在JVM的存储空间主要包含三个重要区域: 方法区, 栈, 堆. java程序被运行时, 首先将代码片段存储至方法区中, 调用方法时将方法栈帧压入栈区, 使用new运算符时在堆上为对象分配内存. 静态变量在类加载时初始化, 所以存放在方法区. 每个对象内部除了自己的成员外, 还存储这一个特殊的引用型成员变量this(存储在堆区).

变量与常量

基本数据类型: long/int/short/byte/boolean/char/double/float

引用数据类型: 其余

循环与条件判断

方法

java中函数的参数传递只有值传递

类(class)

静态代码块与实例代码块

语法例子:

class Animal{
    private String name;
    static String classname = "Animal";
    static {
        System.out.println("static code block of Animal");
        System.out.println("classname:" + classname); // 静态代码块与静态变量初始化的执行顺序与代码顺序一致
    }
    {
        System.out.println("instance code block of Animal");
    }
    public static void main(String[] args){
        new Animal();
    }
}

静态代码块与实例代码块都用的不多, 静态代码块的执行时机为类加载时机, 实例代码块在每次调用构造方法前执行.

构造方法(new)

  • 当一个类没有编写构造方法时, java编译器会自动未知添加一个无参数构造方法, 此构造方法会将所有基本类型的变量赋值为0, 为引用类型的变量赋值为null. 当一个类编写了构造方法后, java将不会自动提供隐含的无参构造方法. 一个好的习惯是让每个类都写上默认的无参数构造方法

  • 由于java中有垃圾回收机制, 所以没有析构函数这种东西

  • java构造方法没有C++那样的冒号赋初值的语法

// 调用构造方法必须使用new关键字
A a = new A();

this

  • 每个对象都会隐含的带着一个实例变量this, 它是一个引用数据类型

  • this只能出现在实例方法, 构造方法中. 当它出现在构造方法中时, 必须出现在第1行, 此时的使用方式为this(...)的形式.

封装

  • 一个好的编程习惯是将所有实例变量都设置为private变量, 并同时提供setAttr与getAttr方法

继承(extends)

继承实际上是将父类的东西除了构造方法/private方法/private变量/静态方法/静态变量以外的所有东西都复制过来一份

注意事项

  • java中只有单继承

  • 没有写继承关系的类默认继承Object类

  • 子类可以定义与父类同名的变量, 不会发生覆盖. 但是同名方法在满足返回类型与参数类型完全相同时会形成覆盖

  • 子类无法直接访问父类的私有成员

  • 父类的构造函数不会被继承

class Animal{
    String name;

}

this与super对比

  • this与super都只能出现在成员函数, 构造函数中

  • super在构造方法中只能出现在第一行, 因此this与super在构造方法中有且仅有一个. 若一个构造方法既没有this(...)也没有super(...), 则自动补上super().

  • super的主要用于访问父类被覆盖的方法或与子类同名的变量.

  • super不是引用, 必须使用super(...)或super.xxx两种形式之一.

方法覆盖与多态

  • 向上转型: 子类对象转换为父类对象. 可自动进行. 一般用这种方式实现多态

    Animal a = new Dog();
a.move()  // 调用的是Dog的move方法, 多态机制

  • 向下转型: 父类对象转换为子类对象. 必须使用强制类型转换符

    Animal a = new Dog();
Dog d = (Dog) d;  // 向下转型需使用强制类型转换符

  • 向上转型与向下转型的说法仅适用于引用数据类型, 基本数据类型应该使用术语: 自动类型转换与强制类型转换.

  • 向下转型有风险, 一般需要使用类似于如下的代码段

    Animal a = new Dog();
// instanceof对于dog is Animal也会判断为true
if ((a instanceof Dog))  // 避免java.lang.ClassCastException
{Dog d = (Dog) d;}  // 向下转型需使用强制类型转换符

方法覆盖也被称为方法重载写 方法覆盖的注意事项为

  • 子类方法的访问权限应高于或等于父类的访问权限, 例如父类为protected, 则子类可以时protected或public

  • 子类方法不能抛出更多的异常

  • 静态方法没有覆盖的概念(不会被覆盖)

  • 父类的私有方法无法被覆盖

  • 多态的含义是编译与运行时有着不一样的状态

  • 覆盖后的返回值类型可以是父类方法的返回值类型的子类

访问权限修饰符(private/protected/public)

参考链接(还未完全阅读完)

属性或方法的访问权限

修饰符类内部同个包的子类同一个包的其他类不同包的子类不同包的其他类

public

Y

Y

Y

Y

Y

protected

Y

Y

Y

Y

N

无修饰符

Y

Y

Y

N

N

private

Y

N

N

N

N

Note: 网上大部分关于无修饰符和protected的访问权限都是错误的, 代码可以参考src/java/access

外部类的访问权限

  • public: public修饰的类在其他包中可见, public修饰的类名必须与文件名一致

  • 默认: 默认类在本包内可见, 在其他包不可见

  • 无private与protected

内部类的访问权限

内部类本身的访问权限可以是private/protected/默认/public四种, 但是IDEA工具会不建议使用protected修饰, 另外, 从设计上看, 内部类应该仅供外部类访问. 因此修饰符应该设为private.

内部类和外部类的访问是相互透明的, 不受内部/外部类成员的控制访问修饰符影响, 都可以相互直接访问, 见下例.

class Outer {
    private int b = 2;
    private class Inner {  // 此处一般建议为private, 否则没必要定义为内部类
        private int a = 1;
        void change() {
            b = 3;
        }
    }
    private void foo() {
        Inner inner = new Inner();
        inner.a = 2;
    }
    public static void main(String[] args) {
        new Outer().foo();
        new Outer().new Inner().change();
    }
}

外部接口/内部接口的访问权限

只能是public的, 所以会省略不写

final关键字

  • 修饰普通数据类型: 相当于C++的const

  • 修饰方法: 该方法不能被重写

  • 修饰类: 该类不能被继承

    public final class A{}

  • 修饰引用数据类型: 可以修改引用内部的值

    final a = new A();
a.data = 1; // OK

  • 修饰成员变量

    class Test02{
    final private int x;
    Test02(){} // 此行报错, java不会默认的为final修饰的成员变量赋值为0
    Test02(int x){this.x = x;}
    public static void main(String[] args){
        Test02 t = new Test02();
        System.out.println(t.x);
    }
}

    final修饰成员变量时一般会与static连用, 表示常量. 命名规范: 全部大写, 单词之间用下划线连接. 常量一般用public修饰.

    class Test02{
    public static final int CLASSNAME = "Test02";
}

package与import机制

语法

javac -cp ".:xx/yy/a.jar" -d . aa/bb/Myclass.java  # 设置classpath, 并以包的形式编译
java -cp ".:xx/yy/a.jar" aa.bb.Myclass  # 运行

package用于声明本文件所在的包

/* 编译方式: javac -d . Test01.java
运行方式: java aa.Test01
注意: 现在这个类的类名是aa.Test01, 不能切换至aa目录下运行java Test01, 也不能切换后运行java aa.Test01
*/

/*注意import后仍然可以使用java.util.Scanner的写法*/
package aa;
//或者可以用 import java.util.*;
import java.util.Scanner;

public class Test01{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        String str = s.next();
        System.out.println("Your input:" + str);
    }
}

注意: java.lang这个package会被自动import, 例如java.lang.String, java.lang.System.

package命名规范

公司域名倒置+项目名+模块名，例如:

com.baidu.projectname.module1

接口(interface)

接口可以看作是特殊的抽象类, 接口中的方法必须都是抽象的(抽象方法可以带有非抽象方法), 语法如下

// 接口中只能有常量和抽象方法, 且这些常量和方法都必须是public的, 可以省略这些修饰符
interface MyMath{
    /*public static final*/ double PI = 3.1415;
    /*public abstract*/ int add(int a, int b);
    /*public abstarct*/ int sub(int a, int b);
}
interface A{int multi(int a, int b);}
// 接口可以多继承接口
interface B extends A, MyMath{}
// 非抽象类实现接口时必须将所有接口都实现
class MyMathImple implements MyMath{
    public int add(int a, int b){return a + b;}
    public int sub(int a, int b){return a - b;}
}
// 一个非抽象类实现多个接口
class MyMathImple2 implements A, MyMath{
    public int add(int a, int b){return a + b;}
    public int sub(int a, int b){return a - b;}
    public int multi(int a, int b){return a * b;}
}
// extends在前, implements在后
class C extends MyMathImple implements A{
    public int multi(int a, int b){return 1;}
}
public class Test{
    public static void main(String[] args){
        Mymath mm = new MyMathImple();
        mm.add();  // 可以使用多态
        // 诡异: 语法上可以这么干, 编译不报错, 但是运行时会报错
        A a = (A) mm;
    }
}

备注: 接口使用的比较多, 抽象类使用的相对较少

default关键字

见Iterator与Iterable源代码

常用的一些接口

Iterable接口与Iterator接口

注意, 由于java历史原因, Iterable在java.lang包内, 因此无需import, 而Iterator在java.util包内, 因此必须import.

Iterator的源代码如下

package java.util;
import java.util.function.Consumer;
public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

Iterable的源代码如下

package java.lang;
import java.util.Iterator;
import java.util.Objects;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Consumer;
public interface Iterable<T> {
    Iterator<T> iterator();
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

抽象类(abstract)

abstract class Account{  // 抽象类
    public abstract void show();  // 抽象方法, 注意没有它方法体
    public void foo(){System.out.println("foo");}
}
class Credit extends Account{
    public void show(){System.out.println("credit");}
}

public class Main{
    public static void main(String[] args){
        Account a = new Credit();
        a.show(); // OK, 适用多态机制, 调用子类的方法
    }
}

抽象类的子类可以是抽象类或者是普通类

抽象类中可以没有抽象方法, 但是抽象方法必须出现在抽象类中.

抽象方法必须被重写.

抽象类中有构造方法

abstract与final不能一起用

注意: java中有些方法没有方法体, 但它们不是抽象方法(native关键字修饰的方法调用底层C++实现)

内部类(inner class)

内部类可以定义在方法中, 也可以定义在类中(与成员变量同级), 内部类的访问权限修饰符可以是public/private

内部类分为：

  • 静态内部类，类似静态变量

  • 实例内部类，类似实例变量

  • 局部内部类，类似局部变量，匿名内部类属于局部内部类

使用内部类可读性差，尽量不用

class Test{
    static class Inner1{}  // 静态内部类 Test.Inner1 = new Test.inner1()
    class Inner2{}  // 实例内部类 Test.Inner2 inner = new Test().new Inner2()
    public void doSome(){
        int i = 100;
        class Inner3{}  // 局部内部类
        Inner3 inner = new Inner3()
    }
    public void doOther{
        // Inner3在这里不能使用
        // 匿名内部类的使用
        int a = new A(){
            int add(int a, int b){return a+b;}
        }.sum(1, 2);
    }
}

interface A{
    int add(int a, int b);
}

泛型机制

基本语法

class MyType<T>{
    public T a;
}
public class Main{
    public static void main(String[] args){
        MyType<Integer> mt = new MyType<Integer>();
        System.out.println(mt.a);
    }
}

高级用法

异常

多线程（待完善）

线程

概念

java 中有两类线程：

  • 用户线程：例如主线程（以及下面所写各种线程）

  • 守护线程（后台线程）：例如垃圾回收线程，所有用户线程结束后，守护线程将自动结束。守护线程一般都是些死循环

语法：定义

// 方法一：继承java.lang.Thread类
class MyThread extends Thread{
    @override
    void run(){
        Thread t = Thread.CurrentThread();
        System.out.println(t.getName());
    }
}
// 方法二：实现java.lang.Runable接口（更为推荐）
class MyRunable implements Runnable{
    void run(){
        Thread t = Thread.CurrentThread();
        System.out.println(t.getName());
    }
}

// 守护线程(定义的语法上与普通线程无异)
class DeamonThread extends Thread{
    @override
    void run(){
        while(true){
            try {
                Thread.sleep(1000);
                // 备份数据代码
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

语法：使用

线程生命周期：

新建状态：new 执行后进入此状态

就绪状态：start 执行完后进入此状态

运行状态：抢到CPU时间片后由就绪状态进入运行状态，时间片结束后回到就绪状态

阻塞状态：遇到阻塞状态例如调用 Thread.sleep(1000) 时进入此状态，阻塞结束后回到就绪状态

死亡状态：整个 run 函数执行完毕

class Test{
    public static void main() {
        MyThread t1 = new MyThread();
        MyRunable r = new MyRunable();
        Thread t2 = new Thread(r);
        DeamonThread t3 = new DeamonThread();
        t3.setDeamon(true);  // 设置守护线程
        t3.start();
        
        t1.start();
        t1.join();  // 等待t1线程的run函数结束
        t2.start();
    }
}

线程同步（synchronized）

语法

// 给obj加锁
synchronized (obj) {
    // code
}

// 修饰实例方法，表示给this加锁
synchronized void foo() {
    // code
}

// 修饰静态方法，表示给类加锁
synchronized static void foo() {
    // code
}

java 中的三种变量类型：

存储位置

实例变量

堆

线程之间可能是共享的

静态变量

方法区

线程之间可能是共享的

局部变量

栈

不共享

死锁

// DeadLock.java
package com.xxx.java.deadlock;
public class DeadLock{
    public static void main(String[] args){
        Object o1 = new Object();
        Object o2 = new Object();
        MyThread1 t1 = new MyThread1(o1, o2);
        MyThread2 t2 = new MyThread2(o1, o2);
        t1.start();
        t2.start();
    }
}

class MyThread1 extends Thread{
    Object o1;
    Object o2;
    public MyThread1(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){
            }
        }
    }
}

class MyThread2 extends Thread{
    Object o1;
    Object o2;
    public MyThread2(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){
            }
        }
    }
}

上述代码必然发生死锁现象

规避死锁的 rule of thumber：不要嵌套使用 synchronized。

例子：定时器

实现定时器可以手动使用 Thread.sleep 来实现，或使用内置的 java.util.Timer，或 Spring 框架中的 SpringTask 等等。下面简述 java.util.Timer 的使用方法

// TimerTest.java
import java.text.SimpleDate

内置数据结构

String、StringBuffer、StringBuilder

类名

java.lang.String

不可变

java.lang.StringBuffer

可变

线程安全（synchronized 修饰）

java.lang.StringBuilder

可变

非线程安全

String a = "ab";  // "ab"这个String对象被放在方法区的字符串常量池中
// "ac"也在字符串常量池中, 并且堆中有一个String对象
String b = new String("ac");
String c = "ab";
String d = new String("ac")
System.out.println(a == c); // true
System.out.println(b == d); // false
// 推荐写法
System.out.println("ab".equals(a));  // true

八种基本数据类型的包装类

JDK 1.5 之后，自动装箱拆箱：

Integer i = 100;  // 自动装箱
int j = i;  // 自动拆箱
Integer.MAX_VALUE;
Integer.MIN_VALUE;

int, byte, short, long, float, double, boolean, char

Integer, Byte, Short, Long, Float, Double, Boolean, Character

杂录

java中似乎不会区分声明与定义, 更仔细地说, 只有"声明", 也可以理解成声明时包含了定义. 这体现在编写类的时候函数的代码需写在类内部

java中只允许单继承, 多继承通过interface实现

只引入java.util.Iterator则可以使用Iterable标识符

has a关系 => 类组合

is a关系 => 类继承

like a关系 => 类实现接口

java关键字列表

基本类型相关: byte, short, int, long, float,double, boolean, char, strictfp, void

控制结构相关: if, for, else, while, do, continue, break, switch, case, default, return

访问权限相关: public, protected, private

异常相关: throw, throws, try, catch, finally

常量: final

包相关: package, import

调用构造函数: new

类相关: class, interface, static, enum, abstract, extends, implements, this, super, instanceof

小东西: assert

声明该函数底层用计算机相关语言实现: native

transient: 声明不用序列化的成员

synchronized: 声明一段代码同步执行

volatile: 声明多个变量同步发生变化

保留关键字, 没有实际含义: goto, constant

Object源码分析

重写finalize方法可以在垃圾回收时机做些事情, 垃圾回收器会自动调用这个方法. 但垃圾回收器的执行时机是不可控的. 它可能会垃圾太多了垃圾回收器才会启动

// Object源代码, JDK在9.0版本后不能重写这个方法
@Deprecated(since="9")
protected void finalize() throws Throwable{}
A a = new A();
a = null;
System.gc();  // 建议启动垃圾回收器, 但它依然可能不启动

自动类型推断

JDK 8引入, 如下写法可以正常编译通过.

List<Animal> ls = new List<>();

java内存分析

参考algorithm 4 page201-204分析.

在64位机器上,

  • 每个对象一般有16字节的额外开销(overhead)

  • 引用数据类型占用空间为8字节

  • 每个对象所占字节数为8的整数倍(字节对齐)

  • 实例内部类需要8字节的额外开销

  • String对象需要40字节, 其内部的字符数组另外计算

例子1:

public class Date{
    private final int month;
    private final int day;
    private final int year;
}

Date类的对象所占空间为32字节: 其中overhead为16字节, 3个整型数据各占4个字节, 再加4字节补齐至8的整数倍.

例子2

public class Counter{
    private final String name;
    private int count;
}

Counter类的对象所占空间为32字节: 16(overhead)+8(String是引用类型)+4(int类型)+4(overhead)

例子3:

public class Stack<Item> implements Iterable<Item>
{
    private Node first;
    private int N;
    private class Node{
        Item item;
        Node next;
    }
    public boolean isEmpty() { return first == null; }
    public int size() { return N; }
    public void push(Item item) {
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
        N++;}
    public Item pop() {
        Item item = first.item;
        first = first.next;
        N--;
        return item;}
}

占用内存为$32+64N$个字节

  • 其中Stack类本身带有16字节的overhead, 8字节的Node引用, 4字节的整数, 加上4字节的padding. 因此在堆上每个Stack需要分配32个字节.

  • 每个Node对象需要16字节的overhead, 由于是Node是内部类, 还需要8个字节的overhead, 再加上两个引用16个字节, 所以一个Node需要40个字节. 而每个Node所指向Integer类型需要24字节(16字节的overhead+4字节的整型+4字节的padding). 所以每次增加一个节点, 总共需要64字节的开销.

例子4:

int[] a = new int[N];

a占用$24+4N+padding$的内存, 因为数组也是对象, 所以有16字节overhead, 加上记录长度的整数为4字节, 加上4字节padding为24字节. 存储每个整数需要4字节, 共$4N+padding$字节.

例子5:

Date[] a = new Date[N];

数组本身分析同上, 需要24字节, 每个Date对象占32字节, 每个Date对象还需要一个额外的引用8字节. 因此一共为$24+40N$字节.

例子6:

double[][] a = new double[M][N]

占用内存为$24+32M+8MN$, 首先数组需要24字节, 数组的每个元素都是一个数组, 每个需要8字节的引用, 所以需要$8M$字节, 而每个内层数组double [N]需要$24+8N$的大小, 所以总共需要$24+8M+M(24+8N)=24+32M+8MN$字节

例子7:

String类型, 本身作为对象有16字节开销, 内部数据为一个字符数组及3个整数, 需要8+12=20字节, 最后padding为4个字节. 因此总共为16+8+12+4一共40个字节. java内部实现时很多字符串可以共用一个内部的字符数组, 因此字符数组的开销不能简单记为$24+2N+padding$.

备注:

  • 实例内部类才会有8 byte的额外开销, 静态内部类没有8 byte的额外开销

    参考: stackoverflow, algs4-question

  • JAVA虚拟机存在一个小整数池, 用以节约内存, 因此一个全为1的整数数组的开销可能会比较小, 参考algs4-question

Iterator实现细节

当一个Iterator被创建后, 原始对象被修改了, 工程实现上应该抛出异常: java.util.ConcurrentModificationException

Notes:

在C++标准库中, 类似的情况也有, 尚不清楚STL是怎么处理这个问题的.

Springboot

PreviousJavaNextSQL

Last updated