Java语法 1小时入门

1、基本数据类型

1.1 Java是强类型语言

• 所有变量必须先声明后使用。
• 指定类型的变量只能接受与它类型匹配的值。

1.2 Java的类型分类

• 基本类型
• 引用类型

public class Main {

    public static void main(String[] args) {
        //  基本数据类型
        byte a_byte = 1;
        short a_short = 1;
        int a_int = 1;
        long a_long = 1;
        float a_float = 1.0f;
        double a_double = 1.0;
        boolean a_boolean = true;
        char a_char = 'c';
    }
}

1.3 类型转换

1.3.1 自动类型转换

范围小可以自动转化为范围大的数据类型。

1.3.2 强制类型转换

范围大的向范围小转换。

语法：

(targetType)value

1.3.3 表达式类型的自动提升

• 所有的byte short char 提升到int
• 数据类型自动提升为最高等级操作数的类型

1.4 直接量

能指定直接量的三种类型： 基本类型，字符串类型，null类型。

tips： 如果程序第一次使用字符串直接量，java会使用常量池（constant pool）来缓存改字符串直接量。后面在使用该字符串直接量，会直接使用常量池中的字符串直接量。

1.5 运算符

1.5.1 算术运算符

+ - * / += -= *= /=

2、流程控制

public static void main(String[] args) {
    // if else
    int score = 50;
    if (score > 90) {
        System.out.println("优秀");
    } else if (score > 70) {
        System.out.println("中等");
    } else if (score > 60) {
        System.out.println("及格");
    } else {
        System.out.println("差的");
    }

    //  只能是 byte short char int enum String 不能是boolean
    //  可以省略 case 后面的花括号
    switch (score) {
        case 50:
            System.out.println("50分");
            System.out.println("不够优秀");
            break;
        default:
            System.out.println("考了 = " + score);
            System.out.println("优秀吗");
            break;
    }

    // while
    int count = 10;
    while (count < 20) {
        System.out.println("---------" + count);
        count++;
    }

    // do while
    do {
        System.out.println("----------" + count);
        count--;
    } while (count < 10);

    // for
    for (int i = 0; i < 10; i++) {
        System.out.println("i = " + i);
    }
}

3、 面向对象

3.1) 基本语法

public class Person {
    // filed
    private static String country;
    private int age = 0;
    private float height;
    private boolean sex;

    // 非静态变量的初始化代码块
    {
        System.out.println("非静态初始化代码块");
        age = 10;
        height = 12.9f;
        sex = true;
    }

    // 静态变量的初始化块
    static {
        System.out.println("静态初始化代码块");
        country = "china";
    }

    // 构造方法，如果不定义构造方法，系统自动会生成一个默认的没有参数的构造方法
    public Person(int age, float height, boolean sex) {
        this.age = age;
        this.height = height;
        this.sex = sex;
    }

    // 静态方法
    public static void say() {
        System.out.println("I'm " + country);
    }

    // 可变参数，values相当于一个数组
    public void eat(Object... values) {
        for (Object value : values) {
            System.out.println(value);
        }
    }

    // 方法的重装，方法名相同，参数列表不同，返回值类型，和修饰符和方法重载没有关系
    public void work(String job) {
        System.out.println("job is" + job);
    }

    public void work(String job, String where) {
        System.out.println("at " + where + "job is" + job);
    }

    @Override
    public String toString() {
        return ("age =" + age + "height =" + height + "sex =" + sex);
    }

    public static void main(String[] args) {
        Person person = new Person(10, 121.0f, false);
        System.out.println(person);
    }
}

局部变量定以后，必须显示初始化才能使用。

成员变量定义后，不必初始化，系统会给一个默认值。

3.1.1）访问权限修饰符：

public > protected > default > private

一个类就是一个小模块，在程序设计时，应尽量避免一个模块直接操作和访问另一个模块的数据，模块设计要求高内聚，低耦合。

// 声明包
package 包名

// 导包
import 包
// 静态导入，导入静态变量，静态方法
import static 包

java中常用的包

java.lang
java.util
java.net
java.io
java.text
java.sql

3.1.2）继承

java的类只能有一个直接父类。

子类可以复写父类的方法，遵循一个原则：两同两小一大。

两同：方法名相同，形参列表相同。
两小：子类方法返回值类型应比父类方法返回值类型更小或者相等，子类方法声明抛出的异常比父类方法声明抛出的异常更小或者相等。
一大：子类方法的访问权限应比父类方法的访问权限更大或者相等。

3.1.3 ) super

public class SubClass extends SuperClass {
    private int a;

    public SubClass(int a) {
        // 调用父类被复写的方法
        super(a);
    }

    @Override
    public void test() {
        // 调用父类被隐藏的变量
        System.out.println(super.a);
    }
}

class SuperClass {
    public int a;

    public SuperClass(int a) {
        this.a = a;
    }

    public void test() {
        System.out.println(a);
    }
}

3.2) 多态

引用变量有两种类型：一个编译时类型，一个是运行时类型。

class Person {
    private String name;

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

    public void say() {
        System.out.println("I'm " + name);
    }
}

public class Man extends Person {
    private int age;

    public Man(String name, int age) {
        super(name);
        this.age = age;
    }

    @Override
    public void say() {
        super.say();
        System.out.println("age is " + age);
    }

    public static void main(String[] args) {
        // 编译时 Person 运行时 Man
        Person person = new Man("wangbo", 20);
        person.say();
    }
}

3.2.1）引用变量的强制类型转换

• 基本类型之间的转换只能在数值类型之间进行。
• 引用类型之间的转换只能在具有继承关系的两个类型之间进行。

3.2.2）instanceof 运算符

注意：

• instanceof是运算符不是一个方法。
• 它的作用是判断前面的对象是否是后面的类或者子类的实例。如果是返回true，否则返回false。
• 前面的操作数编译时类型要么与后面的类型相同，要么与后面的类型具有父子继承关系，否则编译错误。

null instancof Person //返回永远为false，null不是
if (null instanceof Person){
    System.out.println(true);
} else {
    System.out.println(false);
}

继承破坏封装，建议采用组合实现复用

• 继承是 is-a关系
• 组合是 has-a关系

3.3 初始化块

它是类的第四个成员（成员变量，方法，构造器）。初始化块和构造器的作用类似，但比构造器率先执行。

static {
  // 静态初始化块，对类进行操作，同样不能访问非静态成员
}

{
  // 普通初始化块，对对象进行操作
}

执行顺序：

静态初始化块 --> 前面执行(普通初始化块，声明实例变量指定的默认值) --> 构造器

普通初始化块和声明实例变量指定的默认值，谁在前面谁先执行。

3.3.1) 初始化块与构造器

• 初始化块是一段固定执行的代码，不能接受任何参数。因此初始化块对同一个类的所有对象所执行初始化处理完全相同。
• 构造器接受参数，不同对象所执行的初始化处理不同。
• 初始化块其实是个假象，编译后初始化块会还原到每个构造器中，且位于构造器所有代码掐面。

java文件

public class InstanceInit {
  // 初始化块和声明默认初始化，谁在后面谁的值放到构造器中
    {
        a = 6;
    }
    private int a = 9;

    public static void main(String[] args) {
        System.out.println(new InstanceInit().a);
    }
}

class文件

public class InstanceInit {
    private int a = 6;

    public InstanceInit() {
        this.a = 9;
    }

    public static void main(String[] args) {
        System.out.println((new InstanceInit()).a);
    }
}

3.4 包装类

基本数据类型对应的类。

byte -> Byte
short -> Short
int -> Integer
boolean -> Boolean
long -> Long
char -> Character
float -> Float
double -> Double

JDK1.5之前，装箱和拆箱比较麻烦，JDK1.5之后能够自动装箱和拆箱

3.4.1) 自动装箱和拆箱

// 自动装箱
Integer inObj = 8;
Object boolObj = true;

// 自动拆箱
int it = inObj;

3.4.2）String与基本类型之间的转换

// 字符串转基本类型
String intStr = "123";
int it1 = Integer.parseInt(intStr);
int it2 = new Integer(intStr);

// 基本类型转换字符串
String ftStr = String.valueOf(2.35f);

3.5 ） toString、== 、equals方法

toString方法在直接打印对象时，自动调用的方法。一般会自定义，来输出想输出的属性

==

• 基本类型：直接判断值是否相等

• 引用类型：判断引用是否是同一个对象，不能用于比较类型上没有父子关系的两个对象。

  [图片上传失败...(image-e4fa44-1571732324683)]

equals()

• equals()方法是Object类提供的一个实例方法。
• 如果不复写的话，和 == 一样也是用来判断是否指向同一个对象。
• 一般复写，提供自定义的相等标准。

public class Person {
    private String name;
    private String idStr;

    public Person(String name, String idStr) {
        this.name = name;
        this.idStr = idStr;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        // instanceof 运算符前面对象是后面类的实例活其子类的实例都返回true，所有用instanceof判断对象是否为同一个可能有问题
        if (obj != null && obj.getClass() == Person.class) {
            Person person = (Person) obj;
            if (this.idStr.equals(person.idStr)) {
                return true;
            }
            return false;
        }
        return false;
    }
}

3.6）类成员

java类里只能含有成员变量，方法，构造器，初始化块，内部类（接口，枚举）五种。

3.7）final修饰符

final关键字可用于修饰类、变量和方法。

3.7.1）final成员变量

final变量获得初始值之后不能被重新赋值。

final修饰的成员变量必须由程序员指定初始值，系统不会指定默认值。

• 类变量：

  • 静态初始化块
  • 声明类变量时指定默认值

• 实例变量：

  • 非静态初始化块
  • 声明实例变量指定默认值
  • 构造函数中指定初始值

  只能是其中之一初始化

分析原因：

final修饰的成员变量，如果不指定初始值，系统分配默认值，之后不能修改。这些成员变量也就失去了意义，所以系统要求final成员变量必须主动初始化。

3.7.2）final修饰局部变量

局部变量系统不会提供默认值，final修饰的局部变量也可以不指定默认值，后面再指定。

public class Person {
    
    public void test(final int a){
        // 不能对final修饰的形参赋值
        // a = 5;
    }
    
    public static void main(String[] args) {
        final String name;
        name = "hello";
        System.out.println(name);
    }
}

3.7.3）final修饰基本类型变量和引用类型变量的区别

public class Person {
    public static void main(String[] args) {
        // 修饰基本类型，不能修改值
        final int age = 10;
        // age = 11;
        
        // 修饰引用类型
        final List stringList = new ArrayList<>();
        
        // 引用类型的指针地址不变，内容改变
        for (int i = 0; i < 10; i++) {
            stringList.add("--" + i);
        }
    }
}

3.7.4) final 方法

final修饰的方法不能被复写，但是可以重载。

public class FinalMethodTest {
    public final void test(){}
}

class Sub extends FinalMethodTest{
    // 下面方法定义将编译出错，不能复写final方法
    public void test(){}
}

public class FinalMethodTest {
    private final void test(){}
}

class Sub extends FinalMethodTest{
    // 父类private的方法，子类不可见，子类中的test是重定义的
    private void test(){}
}

3.7.5）final类

final类不能被继承。

3.7.6）不可变类

• private和final修饰成员变量
• 提供参数构造器，用于传入参数初始化类的成员变量
• 仅为该类的成员变量提供getter方法，不要为该类提供setter方法
• 如有必要，重写hasCode()和equals()方法。
• 线程安全的。

一般不可变量用于数据层的itemInfo。不可变类的引用类型的成员变量，在赋值的时候最好复制一份，避免直接赋值，因为外部可能修改这个引用类型的变量。

public class ImmutableClass {
    private final int id;
    private final String name;

    public ImmutableClass(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ImmutableClass that = (ImmutableClass) o;
        return id == that.id &&
                Objects.equals(name, that.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

3.8）抽象类

抽象类是从多个类中抽象出来的模板。

• 抽象类被 abstract 修饰，抽象方法也被abstract修饰，不能有方法体。
• 抽象类不能实例化，可以包含成员变量，方法（普通方法和抽象方法）构造器，初始化块，内部类（接口枚举）5种成分。
• 包含抽象方法的类，只能定义成抽象类。
• final 和 abstract 不能共存
• abstract 和 static不能同时修饰某个方法，但却可以修饰内部类。
• abstract 和 private 不能共存。

抽象类的作用： 提供模板，避免子类设计的随意性。

3.8.1）定义

public class Man extends Person {
    @Override
    void eat(String food) {
        System.out.println("eat");
    }

    @Override
    void work() {
        System.out.println("work");
    }
}

abstract class Person {
    abstract void eat(String food);

    abstract void work();

    void sleep() {
        System.out.println("睡觉");
    }
}

3.9）接口

类是具体的实现，接口定义时多个类共同的公共行为规范，是与外部交流的通道。

软件设计：通常会采用面向结构的设计，来实现模块之间的低耦合，同时可扩展性和可维护性更好。

接口的特性：

• 接口可以多继承，类只能单继承。
• Java 8以上接口允许定义默认方法，类方法。
• 接口是一种规范，不能包含构造器和初始化块，可以包含承欢变量（只能是静态常量）方法（只能是抽象方法，类方法，默认方法）内部类（包含内部接口，枚举）定义。
• 接口是公共行为的规范，所以所有的成员都是public权限。
• 接口定义的内部类，内部接口，内部枚举都默认采用public static修饰。
• 接口是一种更加抽象的类，所以java源文件里只能有一个public接口且必须与文件重名。

3.9.1）定义

public interface Output {
    // int MAX_CACHE_LINE = 50; 系统会自动为接口定义的成员变量增加public static修饰符
    public static final int MAX_CACHE_LINE = 50;

    // 接口定义的普通方法默认是public抽象方法
    void out();

    void getData(String msg);

    // 接口里的默认方法，需要使用default修饰
    default void print(String... msgs) {
        for (String msg : msgs) {
            System.out.println(msg);
        }
    }

    // 接口里的类方法，需要static修饰
    static String staticTest() {
        return "接口里的方法";
    }
}

3.9.2）接口和抽象类的区别

• 接口是模块与外界通信桥梁，体现的是一种规范。
• 抽象类是一种模板式设计，多个子类的共同父类。

3.10）内部类

• 内部类提供了更好的封装，不允许同一个包下的其他类访问
• 内部类可以直接访问外部的成员，反过来却不行
• 匿名内部类适用于仅需创建一次使用的类。
• 内部类比外部类可以多使用三个修饰符：private protected static，外部类不可以使用
• 非静态内部类，不能拥有静态成员。
• 非静态内部类实例必须寄生在外部类的实例中，如果其他地方需要使用，就没必要设计成内部类了。

成员内部类，局部内部类，匿名内部类，静态内部类，非静态内部类。

静态内部类

• 静态内部类不能访问外部类的非静态成员。
• 可以包含静态成员。
• 只需要把外部类当成静态内部类的包空间，静态内部类和外部类没啥差别。
• 优先使用静态内部类

匿名内部类：

• 一般是通过接口定义的形式实现匿名内部类
• 匿名内部类只有一个默认的无参构造方法
• java 8之前，要求被局部内部类，匿名内部类访问的局部变量必须是final修饰，java8之后取消了限制，符合上述规则，自动添加final修饰符。

3.11）Lambda表达式

• 用于简化匿名内部类的创建。

• 函数式接口代表只包含一个抽象方法的接口。函数式接口可以包含多个默认方法，类方法，但只能声明一个抽象方法。

• Java8 为函数式接口提供了@FuncaitonInterface注解。

• lambda表达式可以用来赋值。

3.12）引用方法

className::类方法
object::实例方法
className::new

3.13）枚举类

• 枚举类可以实现一个或多个接口，enum定义的枚举类默认继承java.lang.Enum类，Enum实现了Serializable和Comparable接口。
• enum定义非抽象的枚举类，默认使用final修饰。因此枚举类不能派生子类
• 枚举类的构造器只能使用private修饰，省略默认是使用private。
• 枚举类的所有势力必须在枚举类的第一行显示列出，否则这个枚举类永远不能产生实例，这些实例系统会自动加上public static final修饰。
• 枚举类默认提供了一个value()方法，该方法可以方面遍历所有的枚举值。
• 枚举类的实例只能是枚举值，而不是随意通过new来创建枚举类对象。

public enum SearchType {
  // 此处的枚举值必须调用对应的构造函数来创造
    All("all"),
    Product("product"),
    Article("review");

  // 枚举成员一般不可变，这样更安全
    private final String mId;

    SearchType(String id) {
        mId = (id == null ? "" : id.trim().toLowerCase(Locale.US));
    }

    public String getId() {
        return mId;
    }

    public static SearchType getById(String id) {
        id = (id == null ? "" : id.trim().toLowerCase(Locale.US));
        for (SearchType type : SearchType.values()) {
            if (id.equals(type.mId)) {
                return type;
            }
        }

        return null;
    }
}

3.14）对象与垃圾回收

• 垃圾回收机制只负责回收堆内存中对象，不会回收任何物力资源
• 程序员无法精确控制垃圾回收的运行，垃圾回收会在合适的时候运行。当对象永久性地失去引用后，系统就会在合适的时候回收它所占内存。
• 在垃圾回收机制回收任何对象之前，总会先调用它的finalize()方法，该方法可能使该对象重新复活（让一个引用变量重新引用对象），从而导致垃圾回收机制取消回收。

3.14.1）对象在内存中状态

• 可达状态：当一个对象有一个以上的引用变量引用。
• 可恢复状态：某个对象不再有任何引用变量引用它，它就进入可恢复状态。在这状态下，系统的垃圾回收机制准备回收该对象占用的内存，在回收之前会调用finalize()方法进行资源清理，在finalize()调用时可能重新被引用，变成了可达状态。如果确实没有被引用在进入不可达状态。
• 不可待状态：当对象与所有引用变量的关联都被切断，且系统已经调用了finalize()方法后依然没有使该对象编程可达状态，那么这个对象将永久性地失去应用，变成不可达状态。只有不可达状态，系统才会真正回收该对象占用资源。

[图片上传失败...(image-25ef57-1571732324683)]

3.14.2）强制垃圾回收

程序无法精确控制java垃圾回收机制，但是可以强制系统进行垃圾回收 ——这种强制只是通知系统进行垃圾回收，但系统是否进行垃圾回收依然不确定。

• 调用System 类的gc()静态方法：System.gc()
• 调用Runtime 对象的 gc()实例方法：Runtime.getRuntime().gc()

finalize()方法

• 永远不用主动调用某个对象的finalize()方法，该方法应交给垃圾回收机制调用。
• finalize()方法合适被调用，是否被调用具有不确定性，不要把finalize()方法当成一定会被执行的方法。
• 当JVM执行科恢复对象的finilize()方法时，可能是该对象或者系统中其他对象重新变成可达状态。
• 当JVM执行finalize()方法是出现异常时，垃圾回收机制不会报异常，程序继续执行。
• finalze()方法不定义会被执行，因此清理某个类的资源，则不要放在finalize()方法中进行清理。

public class FinalizeClass {
    private static FinalizeClass finalizeClass = null;

    public void info() {
        System.out.println("测试资源清理的finalize方法");
    }

    public static void main(String[] args) {
        new FinalizeClass();
//        通知系统进行资源回收
        System.gc();
//        强制垃圾回收机制调用可恢复对象的finalize()方法
//        Runtime.getRuntime().runFinalization();
        System.runFinalization();

        finalizeClass.info();
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        // 让对象从可恢复状态变成了可达状态，内存泄漏
        finalizeClass = this;
    }
}

3.15）对象的强、软、弱、虚引用

• 强引用（StrongReference）最常见的方式。
• 软引用：通过SoftReference类来实现，当一个对象只有软引用是，他有可能被垃圾回收机制回收。垃圾机制运行时，当系统内存空间充足时，不会被系统回收。程序可使用该对象。当系统空间不足时，系统可能回收它，软引用用于内存敏感的程序中。用的比较少。
• 弱引用：通过WeakReference类实现，弱引用和软引用很像。但若引用的引用级别更低。只有弱引用的对象，当垃圾回收机制运行时，不管内存是否充足，他都会被回收。
• 虚引用：PhantomReference类实现。完全类似没有引用。主要用于跟踪对象被垃圾回收的状态。

软、弱、虚都有一个get()方法，用于获取他们所引用的对象。

4、泛型

4.1) 定义泛型类和接口

public interface Map {
    Set keySet();

    V put(K key, V value);
}

// 设定泛型上限
public class Apple {
    private T info;

    public Apple(T info) {
        this.info = info;
    }

    public Apple() {
    }

    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }

    public static void main(String[] args) {
        // 菱形语法
        Apple apple = new Apple<>("苹果");
        Apple doubleApple = new Apple<>(13.0);
        
    }
}

4.2)泛型类派生子类

// public class A extends Apple 错误的做法
// 派生类需要指定具体类型
public class A extends Apple

public class A extends Apple

注意

List 并不是 List的子类

List list1 = new List<>();
List list2 = new List<>();
List list3 = new List<>();

void test(List list){
  // do something
}

test(list1); // 正确
test(list2); // 错误
test(list3); // 错误

// ? 泛型通配符
void print(List list){
   // do something
}

print(list1); // 通过
print(list2);  // 通过
print(list3); // 通过

// 限定 ? 泛型通配符
void say(List list){
  // do something
}

say(list1); // 通过
say(list2); // 通过
say(list3); // 错误

4.3）泛型方法

修饰符  返回值类型 方法名（形参列表）{

}

public class TFuncation {
    static  void fromArrayToCollection(T[] a, Collection c) {
        for (T o : a) {
            c.add(o);
        }
    }

    public static void main(String[] args) {
        Object[] oa = new Object[100];
        Collection