数组#

// 声明
int array[];
int[] array;
// 初始化
int[] array = new int[5];
int[] array = {0, 1, 2};
int[] array = new int[]{0, 1, 4};
// 错误的示例
int array[5];
int array[5] = {0, 1, 2, 3, 4};
// 索引遍历
for (int i=0; i<array.length; i++) {}
// for-each遍历
for (int value : array) {}

包装类#

包装类就是把基本数据类型和其辅助方法封装到类中，注意基本类型不是类，无法获得类的基本特性（无法参与转型、泛型、集合、反射等过程）。用包装类就是为了弥补这个缺陷。

Integer a = Integer.valueOf(5); // 装箱
int b = a.intValue(); // 拆箱
Integer a = 5; // 自动装箱
int b = a; // 自动拆箱

• 由于包装类的拆装箱过于无感，混用时可能造成性能问题
• 当引用数据类型有更匹配的重载方法时，不会自动拆装箱

包装类比较必须使用equals() ，==比较的是两个引用是否指向一个对象。

包装类的创建很浪费性能，因此java对简单数字(-128~127)对应的包装类进行了缓存，称为常量池。通过直接量赋值的包装类如果在此范围内，会直接使用常量池的引用，因此==返回true。

包装类默认值为null，自动拆箱时会报NullPointerException。

基本语法#

// 类的语法基本结构
/*
class 类名 {
  特征（属性）
  功能（方法）
}
*/

// 创建对象
// new 类名();

class Cooking {
  // 属性
  String name;
  String type = "红烧";
  String food;
  String relish = "大料";
  // 方法
  void execute() {
    System.out.println("准备食材:" + food);
    System.out.println("准备佐料:" + relish);
    System.out.println("开始烹饪");
    System.out.println("烹饪完成");
  }
}

public class Java_Object {
  public static void main(String[] args) {
    Cooking c = new Cooking();
    c.name = "红烧排骨";
    c.food = "排骨";
    c.execute();
  }
}

类和对象#

类是一种结构体，里面包含了属性和方法，会有很多的对象。

对象是类的实例化，一般new出来的对象会赋值给变量，方便重复使用。变量的类型就是对象的类型。对象是将内存地址赋值给了变量，所以变量其实引用了内存中的对象，所以称之为引用变量，而变量的类型称之为引用数据类型。

有一种特殊的对象null。null是没有引用的对象，称为空对象。所有引用类型变量的默认取值是null。

静态#

把和对象无关，只和类相关的称之为静态static。和类相关的属性称之为静态属性，和类相关的方法称之为静态方法。

class Test {
  String name;
  static String sex;
  void test() {
    test1(); // 成员方法可以访问静态属性和静态方法，因为对象先于类存在
    System.out.println("test...");
  }
  static {
    // 对象准备创建时，也会自动调用代码块，但不是静态的
    System.out.println("静态代码块执行"); // 类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化功能
  }
  static void test1() {
    System.out.println("test1...");
  }
}

public class Java_Static {
  public static void main(String[] args) {
    Test t = new Test();
    t.test();
    t.test1();
    Test.test1(); // 两种都可以
  }
}

构造方法#

构造方法专门用于构造对象。如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的、无参的构造方法，方便对象的调用。

• 构造方法也是方法，但是没有void关键字
• 方法名和类名相同
• 如果类中没有构造方法，那么JVM会提供默认的构造方法
• 构造方法也是方法，所以也可以传递参数，但是一般传递参数的目的是用于对象属性的赋值

class User {
  String username;
  User(String name) {
    username = name;
    System.out.println("Name: " + name);
  }
}

继承#

类的继承只能单继承，一个类只能有一个父类，不能存在多个父类。继承采用extends语法。

父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的构建。默认情况下，子类对象构建时，会默认调用父类的构造方法完成父类对象的构建，使用的时super()的方式，只不过JVM自动完成。如果父类提供构造方法，那么JVM不会提供默认的构造方法，那么子类应该显示调用super方法构建父类对象。

class Parent {
  String name = "zhangsan";
	void test() { System.out.println("test..."); }
  Parent() { System.out.println("parent..."); }
}

class Child extends Parent {
  Child() {
    super();
    System.out.println("child...");
  }
}

多态#

多态是一个对象在不同场景下表现出来的不同状态和形态。多态语法是对对象的使用场景进行了约束。一个对象可以使用的功能取决于引用变量的类型。

class Person {
  void testPerson() { System.out.println("test person..."); }
}

class Boy extends Person {
  void testBoy() { System.out.println("test boy..."); }
}

public class Java_Polymorphism {
  public static void main(String[] args) {
    Person p = new Person();
    p.testPerson();
    Person p1 = new Boy();
    // p1.testBoy(); 无法运行
  }
}

重载与重写#

一个类中，不能重复声明相同的方法，也不能声明相同的属性。这里相同的方法指的是方法名，参数列表相同，和返回值类型无关。

如果方法名相同，但是参数列表（个数，顺序，类型）不同，会认为是不同的方法，只不过名称一样，这个操作在Java称之为方法的重载。

class User {
  User() {}
  User(String name) { System.out.println("name: " + name); }
  
  void login(String account, String pwd) { System.out.println("登录"); }
  void login(int tel) { System.out.println("手机验证码登录"); }
}

父类对象的方法主要体现通用性，无法在特殊的场合下使用。如果子类对象需要在特殊的场合下使用，那么就需要重写方法的逻辑，这个操作在Java中称之为方法的重写。这里的重写，并不意味着父类的方法被覆盖掉，只是在当前的场合不使用，如果使用的话可以使用super关键字访问。

方法的重写要求子类的方法和父类的方法名相同，返回值类型相同，参数列表相同

class Parent {
  String name = "zhangsan";
  void test() { System.out.println("parent test..."); }
}

class Child {
  String name = "lisi";
  void test() {
    super.test();
    System.out.println("child test...");
  }
}

访问权限#

Java中的访问权限主要分为四种：

1. private：同一个类中可以使用
2. default：默认权限，当不设定任何权限时，JVM会默认提供权限，包（路径）权限
3. protected：受保护的权限，子类可以访问
4. public：任意使用

内部类#

所谓的外部类就是在源码中直接声明的类，而内部类则是类中声明的类。

Java不允许外部类使用private，protected修饰，内部类就当成外部类的属性使用即可。因为内部类可以看作外部类的睡醒，所以需要构建外部类对象才可以使用。

public class Java_InnerClass {
  public static void main(String[] args) {
    OuterClass outer = new OuterClass();
    OuterClass.InnerClass inner = outer.new InnerClass();
  }
}

class OuterClass {
  public class InnerClass {
    
  }
}

final#

Java中提供了一种语法，可以在数据初始化后不被修改，使用关键字final。

• final可以修饰变量，变量的值一旦初始化无法被修改。一般将final修饰的变量称之为常量，或者叫不可变变量。
• final可以修饰属性，那么JVM无法自动进行初始化，需要自己进行初始化，属性值不能发生变化。
• final可以修饰方法，这个方法不能被子类重写。
• final可以修饰类，这个类就没有子类。
• final不可以修饰构造方法。
• final可以修饰方法的参数，一旦修饰，参数就无法修改。

final String name = "zhangsan";

class User {
  public final String name;
  public User(String name) {
    this.name = name;
  }
  public final void test() {}
}

final class FinalClass {
  public FinalClass() {}
}

抽象#

抽象方法是只有声明，但是没有实现的方法。抽象类是不完整的类，因为类不完整，所以无法构建对象。

如果一个类中含有抽象方法，那么这个类就是抽象类；如果一个类是抽象类，它的方法不一定是抽象方法。

抽象类无法直接构建对象，但是可以通过子类间接构建对象。如果抽象类中含有抽象方法，需要重写抽象方法，将方法补充完整。

abstract关键字不能和final同时使用。

abstract class Parent {
  public abstract void eat();
  public void test() {}
}

class Child extends Parent {
  public void eat() {
    System.out.println("eat...");
  }
}

接口#

接口可以简单理解为规则，是抽象的。规则的属性必须为固定值，而且不能修改，属性和行为的访问权限必须为公共的。

• 属性应该是静态的。
• 行为应该是抽象的。

接口和类是两个层面的东西，接口可以继承其他接口，类的对象需要遵循接口，在Java中这个遵循，称之为实现，类需要实现接口，而且可以实现多个接口。

interface USBInterface {}
interface USBSupply extends USBInterface {
  public void powerSupply();
}
interface USBReceive extends USBInterface {
  public void powerReceive();
}

class Computer implements USBSupply {
  public USBReceive usb1;
  public USBReceive usb2;
  public void powerSupply() {
    System.out.println("电脑提供能源...");
    usb1.powerReceive();
    usb2.powerReceive();
  }
}

class Light implements USBReceive {
  public void powerReceive() {
    System.out.println("电灯接收能源...");
  }
}

public class Java_Interface {
  public static void main(String[] args) {
    Computer c = new Computer();
    Light l1 = new Light();
    c.usb1 = l1;
    Light l2 = new Light();
    c.usb2 = l2;
    c.powerSupply();
  }
}