修饰符

访问修饰符

• 默认的，也称为 default，在同一包内可见，不使用任何修饰符。

接口里的变量都隐式声明为​public static final​,而接口里的方法默认情况下访问权限为 ​public

• 私有的，以 private 修饰符指定，在同一类内可见。

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

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

• 公有的，以 public 修饰符指定，对所有类可见。

• 如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包

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

• Protected 访问修饰符不能修饰类和接口，方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected

访问控制

遵循里氏替换原则

1. 父类中声明为 public 的方法在子类中也必须为 public。

2. 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public。不能声明为 private。

3. 父类中声明为 private 的方法，不能够被继承

非访问修饰符

static 修饰符

• 静态方法不能使用类的非静态变量

final 修饰符

• final 变量

• final 变量能被显式地初始化并且只能初始化一次(不能被再修改）

•  final 对象里的数据可以被改变

• final 修饰符通常和 static 修饰符一起使用来创建类常量

• final 方法

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

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

• final 类不能被继承

abstract 修饰符

• 抽象类：

如果一个类包含抽象方法，那么该类一定要声明为抽象类；抽象类可以有非抽象的方法；

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问

transient 修饰符

volatile 修饰符

java number 类

数据的基本数据类型：byte、int、short、long、double、float、boolean、char；

对应的包装类型也有八种：Byte、Integer、Short、Long、Double、Float、Character、Boolean;

包装类型作用：

• 在有些情况下，能够被处理的数据类型只能是引用类型，如 Java 集合中不能存放基本类型数据，如果要存放数字，应该通过包装类将基本类型数据包装起来，从而间接处理基本类型数据。

• 用于类型转换

System.out.println(Integer.parseInt(s));

String s1 = Integer.toString(1);

String 类

String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了

StringBuilder, StringBuffer

作用：

修改字符串时使用

区别：

StringBuilder 比 StringBuffer 快，但线程不安全，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类

方法

finalize() 方法

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。（相当于 c++的析构函数），一般被声明为 protected

当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法

Java 异常处理

异常种类

• 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

• 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

• 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

异常

所有的异常类是从 java.lang.Exception 类继承的子类。Exception 类是 Throwable 类的子类。

错误

除了 Exception 类外，Throwable 还有一个子类 Error 。Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在 Java 程序处理的范畴之外。例如发生 JVM 内存溢出错误，程序不会从错误中恢复。

finally 关键字

无论是否发生异常，finally 代码块中的代码总会被执行。

自定义异常

• 所有异常都必须是 Throwable 的子类。

• 只继承 Exception 类的自定义异常是检查性异常。

• 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类

继承

java 是单继承，一个子类只能拥有一个父类;但是可以支持多层继承。

public class Device extends Animal, Mammal{} // 非法

但是可以用接口来实现（多继承接口来实现）

public class Apple extends Fruit implements Fruit1, Fruit2{}

所有 Java 的类均是由 java.lang.Object 类继承而来的，所以 Object 是所有类的祖先类，而除了 Object 外，所有类必须有一个父类。

IS-A 就是说：一个对象是另一个对象的一个分类。

HAS-A 代表类和它的成员之间的从属关系。这有助于代码的重用和减少代码的错误

重写和重载

重写

外壳不变，代码内容重写；好处在于子类可以根据需要，定义特定于自己的行为

重写规则

• 参数列表与被重写方法的参数列表必须完全相同。

• 返回类型与被重写方法的返回类型可以不相同

• 子类方法的访问权限必须大于或等于父类方法的访问权限

• 声明为 final 的方法不能被重写

• 声明为 static 的方法不能被重写，但是能再次声明(相当于重写)
  

• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以

• 构造方法不能被重写。

• 如果不能继承这个方法，就不能重写该方法。

• 重写的方法不能比原来的方法权限还低。例如：原来是 public，改成 protected

• 当需要在子类中调用父类的被重写方法时，要使用 super 关键字：super.move()

重载

入参列表不同的同名函数

方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现

多态

抽象类

继承抽象方法的子类必须重写该抽象方法

抽象类可以有构造函数

Java 接口

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

• 接口不能用于实例化对象。

• 接口没有构造方法。

• 接口中所有的方法必须是抽象方法。

• 接口不能包含成员变量，除了 static 和 final 变量。

• 接口不是被类继承了，而是要被类实现。

• 接口支持多继承。

• 接口和它的方法只能被声明为 public 或 abstract

接口重写

• 类在实现接口的方法时，不能抛出强制性异常（在方法参数列表后加 throw xxx），只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
  

• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。

• 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

接口实现

• 一个类可以同时实现多个接口。

• 一个类只能继承一个类，但是能实现多个接口。

• 一个接口能继承另一个接口，这和类之间的继承比较相似；且接口还能多继承

标记接口

没有任何方法和属性的接口

Java 包

作用

Java 使用包（package）这种机制是为了防止命名冲突，访问控制

package net.java.utilpublic class Something{ ...}那么它的路径应该是 net/java/util/Something.java 这样保存的(注意大小写)

如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中

import 声明必须在包声明之后，类声明之前

package huo.pkg.hello;
public class Hello {    public void printPublic() {        System.out.println("pakage test public: hello world");    }
    // 包外只能访问public方法，以下的都不能访问    void printDefault() {        System.out.println("pakage test default: hello world");    }
    protected void printProtected() {        System.out.println("pakage test protected : hello world ");    }
    private void printPrivate() {        System.out.println("pakage test private : hello world ");    }}

包中的类编译之后的.class 文件应该和.java 源文件一样，它们放置的目录应该跟包的名字对应起来。但是，并不要求.class 文件的路径跟相应的.java 的路径一样，如：

<path-one>\sources\com\apple\computers\Dell.java<path-two>\classes\com\apple\computers\Dell.class

查找类时，编译器和 jvm 会默认查找当前目录，然后搜索系统变量 CLASSPATH

数据结构

Vector

和 ArrayList 区别：

• 都是动态数组

• 但 vector 是线程安全，ArrayList 不是，所以 ArrayList 一般场景下更快

Stack

基于 vector 实现

栈可以同时保存不同类型的元素

    void testStack() {        Stack st = new Stack();        st.push(1);        st.push(2);        st.push("abc");
        for (Object s : st) {            System.out.println(s);        }    }

Java 数据结构框架

集合接口：短虚线

抽象类：长虚线

实现类：实现

泛型

泛型，即“参数化类型”

类型参数只能代表引用型类型，不能是原始类型（像 int,double,char 的等）

    <T> T getGeneric(T input) {        System.out.printf("generic type is %s", input.getClass());        System.out.println("");        return input;    }
    void testGeneric() {        Integer i = getGeneric(10);        System.out.printf("generic value is %d", i);    }

限定只能使用某些类型

限定只能使用实现了 Comparable 接口的类型

   // 比较三个值并返回最大值   public static <T extends Comparable<T>> T maximum(T x, T y, T z)   {                           T max = x; // 假设x是初始最大值      if ( y.compareTo( max ) > 0 ){         max = y; //y 更大      }      if ( z.compareTo( max ) > 0 ){         max = z; // 现在 z 更大                 }      return max; // 返回最大对象   }

泛型类

public class Box<T> {   private T t   public void add(T t) {    this.t = t;  }   public T get() {    return t;  }}

序列化

将对象的内存信息序列化后，可以以字节序方式在文件中保存起来；在别的平台如果想使用，反序列化就可以创建出一样的对象