Java初识

基础概念

特点

• 全盘面向对象，动态
• 解释性，简单、易移植，跨平台
• 安徽毛峰健康，高质量
• 多线程，分布式

三种为主机制

• Java虚拟机
  Java
  Virtual Machine

• 废品收集体制 Garbage
  collection

• 代码安全性检测 Code
  Security

留意，Java 语言是跨平台（write once run anywhere）的，JVM
不是跨平台的。Java 的跨平台通过 JVM 完结。

三大平台（技术架构）

• JavaSE：Java Platform，Standard Edition，基础版
• JavaEE：Java Platform，Enterprise Edition，企业版
• JavaME：Java Platform，Micro
  Edition，主要用于移动设备

关于 JVM – JRE – JDK

• JVM ≈ 总括机连串（操作系统+硬件环境）
• JRE（Java Runtime Environment） = java虚拟机 +
  大旨类库(匡助java虚拟机运作的文书)
• JDK （Java Development Kit）= jre + java开发工具

关于
Java.exe – Javac.exe

• Java.exe：java虚拟机解释并执行指定的class文件 （java
  指定的class文件）
• Javac.exe：java编译器对点名的java源文件进行编译 （javac
  java源文件）
• Javap.exe：Java反编译器，javap -c -l -private 类名

关于 Java 的配置

• JAVA_HOME：
• PATH：
• CLASSPATH：

Java源文件结构

Java程序执行步骤： .java源文件，先编译 -> .class(与平台毫无干系的字节码文件) ->
后解释，通过 JVM -> 特定平台的机械码 

  package packageName;
  import | import static packageName;
  public classDefinition | interfaceDefinition | EnumDefinition {}
  classDefinition | interfaceDefinition | EnumDefinition {}

注：一个源文件中不得不有一个public类，否则编译器找不到相应执行的main方法，但是一个源文件中得以有几个非public类。一个源文件中也只可以有一个public接口。一个源文件中也只可以有一个public枚举类。

有关访问修饰符

废品回收

只负责在适龄时间回收堆内存中处于不可达状态的对象。强制（提出）举办垃圾回收措施：

• System.gc() / runFinalization()；
• Runtime.getRuntime.gc() / runFinalization()；

finalize：默许机制，Object 类的实例方法：  protected
void finalize() throws Throwable
 
虚引用：紧要用来追踪对象被垃圾回收的气象。虚引用必须与引用队列联合使用 
JAR包 ：Java 档案文件，Java
Archive File。

• 缩减，加快加载速度；
• 包封装（工具类方法），安全，可移植；

注意事项

• 格式：jar cvf jar文件名 class文件或文件夹
• jar包打完后，要在清单文件中声明入口类（格式：Main-Class: 包名.类名）

 

Java类库

[修饰符] class 类名
{
    初始化块；成员变量；构造器；方法；内部类；
}

　[1]. Scanner 类
　　基黄永辉则表达式的公文扫描器：输入流、文件、字符串。
　[2]. System/Runtime 类　
　　与程序的运作平台/运行时环境相互：环境变量、系统质量以及文件加载、垃圾回收和资源清理。
　　System.identityHashCode(Object
obj)：按照指定对象的地方精确统计到的hashCode值，identityHashCode值唯一标识对象。
　　Java 程序和 Runtime 实例一对一，getRuntime() 获取。Runtime
类可以独自启动一个历程运行操作系统的命令：rt.exec(“命令”)；
　[3]. String/Math 类
　[4]. Random/ThreadLocalRandom 类
　　减少三三十二线程资源竞争，有限协理线程安全行性，静态 current() 方法取得
ThreadLocalRandom 对象。　　
　　Random rand = new Random(System.currentTimeMillis())；
　[5]. BigDecimal 类
　　化解 double 类型精度丢失难题、精确总括浮点数，成立方法：
　　·  基于 String 的构造器创制：new BigDecimal(String str)；
　　·  以 double 参数创制：BigDecimal.valueOf(double value)；
　[6]. Date/Calender 类
　　Date 类不推荐应用。Calender 类是抽象类，静态方法 getInstance() 获取
Calender 对象，Calender 协理较好的容错性。注意，其 set()
方法有延期修改的品质，可以免止接触数十次不须求的盘算。　
　[7]. 其余常用方法
　　·  MessageFormat：格式化字符串；
　　·  NumberFormat：格式化数字；
　　·  (Simple)DateFormat：格式化时间、日期；
　　 => Date提姆eFormatter 格式器类：格式化日期时间、字符串解析；

继承 Inheritance ~ 多态 Polymorphism ~ 组合

类单继承，extends，Java类只好有一个平昔父类。java.lang.Object类是所有类的父类。接口多完毕，implements。
java.lang.Object

• Class<?> getClass()：重返对象的周转时类；

• protected object clone()：高效、(浅)复制获得实例对象的副本；

  class MyObj implements Cloneable {

  public MyObj clone(){
      return (MyObj)super.clone();
  }
  

  }

Java规定：

• 比方几个目的equals重临true，那么那八个对象的hashCode码必须一律
• 在实质上中，应该按需重写 Object 类的 equals() 和 hashCode() 方法

Objects 工具类：空指针安全的
[1]. Objects.requireNonNull(obj)：对章程的形参作输入校验；　　 　
protected ~ final
protected：允许子类重写父类方法，但差距意任何类访问，final是不允许子类重写父类方法。
final：[1]. 变量不可变，方法不可重写，类不或者被延续； [2].
定义宏变量；
不可变类
此类的靶子成立后，对象的实例变量不可变。注意，包蕴引用类型成员变量的不可变类要求提供爱抚措施。
[1]. private final 成员变量；
[2]. 带参的结构器起首化[1]的分子变量，仅提供getter()方法；
this ~ super
this 是调用同一个类中重载的构造，super 是调用父类的构造器。
构造器 ~ 伊始化块
对Java对象实施指定的起初化操作。构造函数是给相应的对象初步化操作。

初阶化块在创造Java对象时隐式执行且在构造器从前。初步化块没有名字标识，修饰符只可以为static，静态起首化块先于普通初叶化块执行。

• 开始化块，即协会代码块啊，是兼备构造函数中的公共部分
• 给所有的目的统一的先河化

有关社团代码块和构造方法的涉嫌（最好通过反编译一个类来打听）

• 成员变量的扬言是在一个类的最前端
• 分子变量的开头化、构造代码块的代码实际上是在构造方法中实践的（反编译可以见见）
  • 社团代码块的代码位于构造方法的代码的面前执行
  • 分子变量的开首化和布局代码块的实施是根据双方在类中的先后地方
  • 构造方法的代码实际上是终极执行的

instanceof ~ (type)
objA instanceof
classB，判断引用类型对象objA是还是不是是classB类或是其子类、完毕类的实例。objA
的编译时类型要么是classB，要么与classB有父子继承关系，否则编译错误。
在恐吓类型转换(type)以前，先举行instanceof判断，幸免出现ClassCastException极度。类似
C# 中的 is 运算符。

if(objA instanceof classB)
    classB objB = (classB)objA;

组合 ~ 继承
类的2种复用机制，组合是把旧类对象作为新类的(private)成员变量举行整合用于已毕新类的机能，继承是(is-a)关系，组合是(has-a)关系；两者开销仅差一个private成员变量。
abstract ~ final ~ static ~ private

abstract类只可以被持续，abstract方法必须由子类重写。
 [1]. abstract不能够与final同时修饰类或艺术；
 [2]. abstract不可以与static同时修饰方法，但足以同时修饰内部类；
 [3]. abstract不可以与private同时修饰方法；
接口 ~ 抽象类
抽象类：abstract，多少个类的模板，模板情势；
接口：interface，多少个类应听从的国有行为规范，面向接口耦合和通讯；
 [1]. 成员变量：静态常量，默许 public static final ；
 [2]. 方法：抽象方法，默许 public
abstract，同时Java8允许在接口里定义默许方法(default)和类格局(static)，注意接口没有构造方法
 [3]. 内部类，内部接口，内部枚举，默许 public static；

多态

数量成员：父类和子类有相同的成员变量，多态下访问的是父类的分子变量

• 当父类和子类具有同样的非静态成员变量，多态下访问的是父类的积极分子变量，编译和运作参照左侧
• 当父类和子类具有相同的静态成员变量，多态下访问的是父类的静态成员变量，编译和运作参照左边

成员方法

• 当父类和子类具有相同的非静态方法（就是子类重写父类方法），多态下访问的是子类的积极分子方法（最常用的多态），编译看左侧，运行看左侧
• 当父类和子类具有相同的静态方法（就是子类重写父类静态方法），多态下访问的是父类的静态方法，编译和周转参照左边

MySQL，内部类

亮点：成员内部类作为外部类的积极分子，可以访问外部类的别样成员

情景：A类和B类，A类想一直访问B类的分子，而B类又需建立A类的靶子来拜会A类中的成员。那时，应该将A类定义成B类的中间类。

作用域

• 表面类：同一个包内(包访问权限)和其他岗位(公共访问权限，public)
• 其中类：同一个类(private)、同一个包(包访问权限)、父子类(protected)和此外岗位(公共访问权限，public)

互相拜访

• 个中类可以一向访问外部类的成员属性
• 外部类须要创建内部类的对象才能访问内部类的分子属性
  • 表面类的成员函数访问：Inner obj = new Inner()
  • 其余类访问：Outer.Inner obj = new Outer().new Inner()
    （假若静态内部类，应为 Outer.Inner obj = new Outer.Inner()）　

专注，内部类无法被外表类的子类重写（类的范围名肯定不相同）。
非静态内部类
实例相关，非静态内部类对象里保存外部类对象的引用，依存于外部类对象；非静态内部类里不可以定义静态成员（至于何以，可以设想类的加载进度，并参考
http://bbs.csdn.net/topics/90510249）；
表面类访问内部类：(new innerClass()).innerVar；
非静态内部类的构造器必须经过外部类对象调用；非静态内部类的子类的对象也存活于外部类对象；
静态内部类
static，类相关，静态内部类对象保存外部类的引用，依存于外部类；接口的内部类默许是
public static；
外部类访问内部类：[1]. (new innerStaticClass()).innerVar；[2].
innerStaticClass.innerStaticVar；
静态内部类的构造器通过外部类调用；　
匿名内部类
匿名内部类不可以重复使用，必须一而再一个父类或促成一个接口。被匿名内部类访问的局地变量默许是
final。最常用的始建匿名内部类的气象是索要创建某个唯有空虚方法的接口类型的对象。

在意，上边介绍的内部类都是成员内部类，还有一种特殊的其中类是概念在外部类的分子函数中，叫局地内部类，局地内部类只可以访问该成员函数的
final 属性。

Lambda 表达式

Java8 引入 Lamba
表明式升级简化匿名内部类、匿超级模特式，允许创造函数式接口的实例。Lambda
表明式的目的项目能且必须是为之侧目标函数式接口，函数式接口只可以声美素佳儿（Friso）个虚无方法。
[1]. 创建临时对象； [2]. 赋值；

格式：（形参列表）->｛代码块/方法体｝  

措施引用 ~ 构造器引用
当方法体只有一条代码时，可以用艺术引用和构造器引用替代 拉姆da 表明式。

格式：类名::类方法/实例方法/new  

本质：利用简洁的语法创立函数式接口的实例！
关于匿名内部类和 Lamba 表达式的异同自行百度。

枚举

枚举类显式继承 java.lang.Enum 类，java.lang.Enum 类已毕了
java.lang.Comparable 和 java.lang.Serializable 五个接口。

• 非抽象枚举类默许 final 修饰，即不可以派生子类
• 枚举类的结构器默许 private 修饰
• 枚举类的实例默许 public static final 修饰 
• 枚举类中声称的各个枚举值代表枚举类的一个实例对象
• 注明枚举类时，也可以注解属性、方法和构造函数
• 枚举类可以表明抽象方法，不过要有切实可行的枚举值去落到实处
• 枚举类可以兑现接口(系列化)、继承抽象类
• 若枚举类唯有一个枚举值，可以当做单例设计格局使用

1. public static <T extends Enum<T>> T
valueOf(Class<T> enumType, string name)
静态方法，用于再次来到指定枚举类中指定名称的枚举值，以枚举类 SeasonEnum
为例：
  — SeasonEnum se =
Enum.valueOf(SeasonEnum.class, “SPRING” );
  — SeasonEnum se =
SeasonEnum.valueOf( “SPRING” );
2. 再次来到枚举常量名称、索引值
  — SeasonEnum.SPRING;
  — SeasonEnum.SPRING.name();
 
— SeasonEnum.SPRING.toString();
  — SeasonEnum.SPRING.ordinal();
 // 索引值　
3. 抽象枚举类
枚举类中应用 abstract 定义抽象方法，枚举类默许修饰为
abstract，同时各个枚举值必须显式已毕抽象方法。

Java 集合

Java 集合分为 List、Set、Map、Queue 七种连串，接口 Collection 和
Map 是 Java 集合框架的根接口，List、 Set 和 Queue 接口派生于 Collection
接口。非类型安全，以 Object 类型存储，须求强制类型转换。　
Collection
 —  Iterator
iterator()：用于遍历集合成分；
 —  Object[]
toArray()：集合转化为数组；
 —  void removeIf(Predicate
filter)：批量去除满足条件的成分，入参为 拉姆da 表明式；
 —  Stream stream(Predicate
filter)：重回集合对象对应的 Stream 对象；（Stream 编程，利用 Stream
对象的聚众操作简化对聚集的操作），几个流式 API：
 [I]. filter(Predicate predicate)：入参为 拉姆da 表明式，过滤
Stream 对象中不符合条件的因素；
 [II]. toArray()：将流 Stream 对象转换为数组；
 [III]. forEach(Consumer action)：入参为 Lambda 表明式，遍历流
Stream 对象中的成分；
　
List：有序、可重复
线性表接口，提供索引访问、插入、删除、替换。额外措施，入参均可为 拉姆da
表达式：

void sort(Comparator c)； 
void replaceAll(UnaryOperator operator)； 
ListIterator listIterator()； 

里面，ListIterator 接口继承于 Iterator 接口，增添了前向迭代效用，专用于操作 List。 

[1]. ArrayList（使用频率非凡高） – Vector（线性安全的ArrayList）
List 接口的兑现类，基于数组，默许长度10，每一回扩容增进60%（1.5倍，(oldCapacity * 3)/2

• 1），封装了一个同意动态再分配的
  Object[] 数组。ArrayList 非线程安全（单线程功能高），Vector
  线程安全（十二线程安全，效能低），质量低于 ArrayList。继承于 Vector 类的
  Stack 子类也是线程安全的。推荐 Object get(int index) 随机访问成分。

[2]. LinkedList

类 LinkedList 既贯彻 List 接口，也促成 Deque 接口，基于链表。推荐 Iterator 迭代器随机访问成分。

Collection接口继承接口Iterable，Collection种类都独具获取自我迭代器的章程，只不过各种子类集合都开展了重写（因为数据结构不相同）

ListIterator：List的故意迭代器，在迭代进度中援救添加或改动成分。而此外常常的迭代器，仅仅协助获取和删除操作。
小结：性能 ArrayList >
LinkedList。

Queue：队列集合
提供 offer() 和 poll() 入队和出队。
[1]. Deque -> ArrayDeque
接口 Deque 继承于 Queue 接口，代表”双端队列”，可以视作”栈”使用。
Iterator descendingIterator()；逆向迭代双端队列 
类 ArrayDeque 既贯彻 Deque接口，也完结 List
接口，可以看作”栈”使用，基于数组。
[2]. PriorityQueue
预先级队列，不允许 null 值。排序效能、成分非FIFO，排序方法参见
TreeSet。
Set：无序、不可重复
[1]. HashSet -> LinkedHashSet
HashSet 是 Set 接口的兑现类，非线程安全。底层哈希表完毕，按 Hash 算法
存储成分（根据元素的 hashCode
值总结存储地方并判重），成分值可以为null，存取和寻找速度快。2 个 HashSet
成分相等的充要条件：

obj1.hashCode()==obj2.hashCode() && obj1.equals()==obj2.equals();  

要素的哈希值通过成分的hashcode方法得到，首先判断多少个要素的哈希值，如若哈希值一样，接着会比较equals方法，假诺equls为true，视为同一个因素，借使equals为false就不是同一个要素（存储地点：同一个hashCode地方上得以存放四个成分。）。

注：为力保 HashSet
功效的落实，hashCode() 和 equals() 方法是或不是重写须要有限支撑同步。
~> LinkedHashSet
HashSet 的子类。利用链表维护成分的插入顺序，质量略低于 HashSet。
[2]. SortSet -> TreeSet
TreeSet 是 SortedSet 接口的落到实处类。按 红黑树
的数据结构有序存储同种类成分：

• 本来排序：默认排序，成分类自己必须落成 Comparable 接口的 int
  compareTo(Object obj) 方法。
• 定制排序：容器类必须关联 Comparator 接口的 int compare(Object o1,
  Object o2) 方法。

当成分本身不享有比较性，只怕成分自个儿持有的比较性不是所需的，此时内需让容器本身兼备相比较性。

概念一个类完结Comparator接口，落成compare方法，并将该接口的子类对象作为参数传递给TreeSet集合的构造函数。

class MyComparator implements Comparator {
    public int compare(Object o1, Object o2) {

        }
}

当Comparable比较艺术及Comparator比较艺术同时设有，以Comparator相比较艺术为主。

2 个 TreeSet 成分相等的充要条件：

0 == this.compareTo(obj)  // 自然排序
0 == (Comparator对象 | Lambda表达式).compare(t1,t2)   // 定制排序

注：为有限支撑 TreeSet
成效的兑现，自然排序中 compareTo() 和 equals() 方法须保持同步。
~> SortedSet
SortedSet 接口继承自 Set 接口。
[3]. EnumSet
枚举类型成分的静止集合类，以枚举值在 Enum
类中的定义顺序决定集合中成分的次第，成分不允许为null。Enum 对象在中间以
位向量 的款型储存，紧密高效、占用内存小、运行效用好。

EnumSet es = EnumSet.Allof/noneOf(Season.class);　　　  

小结：EnumSet 是独具 Set
已毕类中质量最好的，品质 HashSet >
TreeSet。HashSet、TreeSet、EnumSet 均线程不安全。

Map：映射集合
事关极度， Map 的 key 值集合是 Set，value 集合是 List，Map 提供 Entry
内部类封装 key-value对，通过 get(Object key)/remove(Object key)
获取和删除成分。
HashMap – Hashtable -> LinkedHashMap
HashMap 非线程安全、key和value 允许为 null，Hashtable
线程同步安全，key和value 不允许为 null，品质 HashMap > Hashtable。2
个 key 值相等的充要条件：

obj1.hashCode()==obj2.hashCode() && obj1.equals()==obj2.equals();  

2 个 value 相等的充要条件：

obj1.equals()==obj2.equals();

注：为力保 HashMap-Hashtable
功用已毕，hashCode()和equals()方法是否重写需维持同步。
~> LinkedHashMap：
HashMap 的子类。利用双向链表维护成分的插入顺序，质量略低于 HashSMap。
~> Properties：
Hashtable 的子类，key和value 均为 String 类型的 Map，store()和load()
存储和加载 属性文件。
SortedMap -> TreeMap
类 TreeMap 是 SortedMap 接口的落到实处类。按 红黑树 有序存储同种类成分：参考
TreeSet。
EnumMap
内部以数组款式保留，紧密高效，key 值无法为
null，必须与枚举类关联。
小结：性能 HashMap >
TreeMap，EnumMap 质量最好。
　
Iterator：迭代器，必须依附于 Collection
对象。
　– boolean hasNext()：
　– Object next()：
　– void
remove()：用于删除集合里 next() 方法上两回回到的成分；
　– void
forEachRemaining(Consumer action)：利用 拉姆da 表明式遍历集合成分；
注：Iterator 迭代器接纳 fast-fail 火速战败机制，迭代 Collection
集合时，集合成分无法被修改，否则登时抛出 ConcurrentModificationException
分外。

Collections：集合工具类，静态方法
[1]. 排序、查找、替换等
　– void
sort/reverse/swap/shuffle/retate(List list)：
排序/反转/交流/随机排序/旋转
　– int binarySearch(List list,
Object key)：二分查找
　– void fill(List list, Object
obj)：成分填充
　– boolean replaceAll(List
list, Object oldObj, Object newObj)：元素交替
[2]. 同步控制
提供 synchronizedXxx()
方法将点名集合打包程线程同步的会聚，解决八线程并发访问集合时的线程安全难点。

Arrays：集合工具类，静态方法

泛型 Generic

花色安全检查，防止引起 ClassCastException
分外。以泛型List为例，类型通配符 List<?>
可以象征各类泛型List的父类，设定类型通配符的上限 List<? extends
父类>
限制其只表示某一类泛型List的父类，注意运用了花色通配符的汇集差异意添美金素。通配符用于援救灵活的子类化。 

至于泛型，注意以下多少个难点：

• Java 不协理泛型数组
• 泛型类型必须是援引类型（泛型集合不可以储存中央数据类型，须利用基本数据类型的包裹类，int
  —> Integer）

参考
[1]. 泛型知识点总计；
[2].
Java统计篇序列：Java泛型；

异常

Java 的不得了机制重大借助于 try，catch，finally，throw，throws
多少个关键字。其中，finally 用于回收在 try 块中开拓的物理资源，throw
用于机动抛出极度的实例，throws
用于方法签名中申明该办法恐怕抛出相当、并由上顶级调用者处理该更加。Java
的歇斯底里意况有 2 类：Error 和 Exception，均再而三于 Throwale 类。
Runtime 极度(运行时至极)，RuntimeException 类及其子类的实例，灵活易用。

Java的可怜体系

负有的不得了类均在 java.lang 包中。

其间，Throwable
描述不当和充裕，Error（错误）表示不可治愈，Exception（非凡）表示可治愈，卓殊包罗运转时更加和非运行（编译）时极度。

那么些处理格局

• 在出现万分的点子中显式捕获十分并拍卖，方法的调用者不会捕获到充足；
• 在艺术签名中用 throws
  表明抛出万分，万分捕获之后交由调用者处理该越发；

优点

• 正常工作代码和卓殊处理代码分离
• 先后容错性，健壮、易维护；
• 提供多更加捕获功用；

动用注意

• 相当处理协会 try 块是必须的，catch 和 finally
  块可选但必须至少二选一；
• finally 块总会执行，return 都不可以终止 finally 的推行，除非 try 或
  catch 块中调用了 System.exit(1)； 退出虚拟机；
• 子类非凡在前，父类极度在后，即先处理小可怜，后处理大极度；

自定义非凡 ：自定义相当类须要提供 2 个构造器。

 1 public class MyException extends Exception | RuntimeException
 2 {
 3     public MyException(){}
 4     public MyException(String msg){
 5         this.super(msg);
 6     }
 7     public MyException(Throwable t){  // 支持异常的链式处理
 8         this.super(t);
 9     }
10 }

不行链 ：链式处理
  捕获 1
个更加后接着抛出另一个格外，同时把原本格外的音信保存下去的机制。

图形用户界面编程 （驾驭即可）

　GUI（Graphic User Interface）编程，图形界面组件库（AWT + Swing）+
事件处理机制。
 ·  AWT，抽象窗口工具集，Abstract Window Toolkit。
基本的窗口框架，重量级组件、器重底层平台；
 ·  Swing，轻量级组件，100% Java 完成，跨平台品质好。拔取 MVC
设计形式，达成 GUI 组件的显得逻辑和数码逻辑的离别，灵活性好；

MySQL – JDBC

　关于 MySQL 的基础，请参考 MySQL 初识 –
sqh；
　关于 JDBC 的基础，请参考 JDBC 初识 –
sqh；

注解

　Annotation，接口，封装元数据，修饰程序成分、提供为其安装元数据的法子，允许在源文件中置放补充音讯，类似
C# 中的天性。程序通过反射能赢得指定成分的 Annotation
对象、进而提取声明中的元数据。Java 8 支持再次申明，需求 @Repeatable
修饰。访问和拍卖 Annotation 的工具为 APT，Annotation Processing
Tool，对源代码文件举办检测，执行适度从紧的代码检查。
　– java.lang 包下的着力 Annotation：
  ·  @Override：限定子类必须重写父类的法门，只好修饰方法；　
  ·  @Deprecated：标记已不合时宜；
  ·  @Suppress Warnings：抑制编译器警告；
  ·  @Safe Varargs：专用于避免堆污染 Heap pollution 警告；
  · 
@FunctionalInterface：函数式接口注明，须要接口只好分包一个架空方法，只能够修饰接口；
　– java.lang.annotation 包下的 元Annotation：
  ·  @Retention：指定 Annotation 的生命周期；
      RetentionPolicy.RUNTIME：　
      编译器将 Annotation 记录在 .class 文件中，运行时得以通过 JVM
或反射获取 Annotation 音讯；
  ·  @Target：指定 Annotation
修饰的指标程序成分，所有程序成分的父接口为 AnnotatedElement；
  ·  @Documented：提示被修饰的 Annotation 接口将被 javadoc
工具提取成文档；
  ·  @Inherited：Annotation 具有父子继承性；
  自定义 Annotation：默认继承
Annotation 接口

 public @interface AnnotationName{...} 

  其中，Annotation 定义中，成员变量必须以无形参方法的花样定义，可以用
default 指定开首值。
  AnnotatedElement
接口：用于提取 Annotation 音讯，实例方法
 　 – 
getAnnotation(xxx)：获取程序成分上的指定注明；
 　 –  getAnnotations()：
获取程序成分上的具有申明；
 　 – 
isAnnotationPresent(xxx)()：判断程序成分上是否存在指定注解；

I/O

   具体参考 Java 输入输出种类学习 –
sqh；

多线程

   具体参考Java 四线程学习 –
sqh；

互联网编程　

   具体参考 Java 网络编程学习 –
sqh；

---

至于默许构造方法

• 若类没有构造方法，java编译器为之添加默许构造方法，若有，不添加
• java编译器为类增进的默许构造方法的拜访权限与类的权力一样

泛型通配符 ？

限制泛型通配符的界线

• 上边界：extends

• 下边界：super 

  ? extends T：接收T类型大概T的子类型
  ? super T：接收T类型或然T的父类型

JDK5中的泛型允许在编制集合代码时，限制集合的处理项目，从而把本来程序运行时只怕暴发难题变更为编译时难题，进步程序可读性和安居。　　

有关数据类型间的强制类型转换

一个数字，若没有项目的识，默许是 int 类型

// 会进行强制类型转换，如果超出类型能表示的范围，会报错，反之不会
byte b1 = 10;  // ok
byte b1 = 1000;  // 编译失败

byte b1 = 10;   byte b2 = 20;
byte b3 = 10 + 20;   // ok
byte b3 = b1 + b2;   // 编译失败

b2 = b1 + b2;   // 编译失败
b2 += b1;   // ok, Java 编译器已经默认对 += 进行强制类型转换

== 与 equals()

• ==：值十分（基本数据类型）、多个引用是还是不是针对同一(内存)对象（引用数据类型）；
• equals()：Object默许提供的equals()方法等效于 ==，实际中按需重写；

直接量 “hello” 与 new
String(“hello”)

• “hello” 是编译时常量，常量池管理之，在常量池中存在且唯一；
• new String(“hello”) 是运行时先用常量池管理 “hello”
  直接量，再布局一个新的String对象存在堆中，实际上一共爆发了2个
  “hello” 字符串对象，再次回到值指向堆内存中的字符串对象；

构造器new 与 valueOf()

• new 构造器创造全新对象
• valueOf创造全新对象并缓存

后自增/减在JVM中的运行规律

int i = 0;
[1]. i++;    // i = 1
[2]. i = i++;   // i = 0

JVM会先声美素佳儿（Friso）个临时变量保存自增/减在此之前的值，最后回到该值作为表明式的值

第一步：int temp = i;   // temp = 0;
第二步：i++;   // i = i + 1;
第三步：return temp, 作为表达式的值

在意，i 在该进程中的变化：i = 0 ——> 1 ——> 0 

Static

静态修饰符，其成员在方法区（数据共享区），优先于对象存在，作为目的的共享数据。

• 静态方法只可以访问静态变量，也不可以动用 this、super 关键字
• 静态代码块优先于一般代码块优先于构造函数，用于对类伊始化
• 静态变量/方法/代码块随着类的加载而加载，随着类的没有而消逝

至于实例变量和静态变量

• 存放地点：类变量随着类的加载而加载存在于方法（共享）区中，实例变量随着对象的创建而留存于堆内存中
• 生命周期：类变量与类同在，实例变量与对象同在

 

Eclipse

关于火速键

Alt + /：内容提示       Ctrl + 1：快速修复，编译异常提示      Ctrl + shift + O：导包
Ctrl + /：单行注释      Alt+上下键：代码位置切换                Ctrl + Shift + F：格式化代码块
Ctrl+Shift+/或\：多行注释    Ctrl+Shift+X/Y：大小写转换
查看源代码：（1）Ctrl+单击 需要查看源码的类；（2）Ctrl+Shift+T