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 类名

MySQL 1

关于 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枚举类。

有关访问修饰符

MySQL 2

垃圾堆回收

仅负责在方便时间回收堆内存中处于不可达状态的靶子。强制(建议)进行垃圾回收措施:

  • 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:格式化时间、日期;
   => DateTimeFormatter 格式器类:格式化日期时、字符串解析;

继承 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;

多态

数成员:父类和子类有一样之积极分子变量,多态下访的凡父类的成员变量

  • 当父类和子类具有同等之非静态成员变量,多态下看的凡父类的分子变量,编译和运行参照左边
  • 当父类和子类具有同样之静态成员变量,多态下访的凡父类的静态成员变量,编译和运作参照左边

成员方法

  • 当父类和子类具有同样的无静态方法(就是子类重写父类方法),多态下访的凡子类的分子方法(最常用之多态),编译看左边,运行看右
  • 当父类和子类具有相同之静态方法(就是子类重写父类静态方法),多态下访的凡父类的静态方法,编译和周转参照左边

内部类

可取:成员里类作为外部类的积极分子,可以看外部类的另外成员

现象: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
表达式的靶子项目会还必须是明确的函数式接口,函数式接口只能声明一个架空方法。
[1]. 创建临时对象; [2]. 赋值;

格式:(形参列表)->{代码块/方法体}  

主意引用 ~ 构造器引用
当方法体只生相同长代码时,可以为此智引用和构造器引用替代 Lambda 表达式。

格式:类名::类方法/实例方法/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 集合分为 ListSetMapQueue 四栽体系,接口 Collection 和
Map 是 Java 集合框架的一干二净接口,List、 Set 和 Queue 接口派生于 Collection
接口。非类型安全,以 Object 类型存储,需要强制类型转换。 
Collection
 —  Iterator
iterator():用于遍历集合元素;
 —  Object[]
toArray():集合转化为数组;
 —  void removeIf(Predicate
filter):批量删减满足条件的因素,入参为 Lambda 表达式;
 —  Stream stream(Predicate
filter):返回集合对象对应的 Stream 对象;(Stream 编程,利用 Stream
对象的集纳操作简化对聚集的操作),几个流式 API:
 [I]. filter(Predicate predicate):入参为 Lambda 表达式,过滤
Stream 对象中未符合条件的元素;
 [II]. toArray():将流 Stream 对象转换为数组;
 [III]. forEach(Consumer action):入参为 Lambda 表达式,遍历流
Stream 对象吃的素;
 
List:有序、可重复
线性表接口,提供索引访问、插入、删除、替换。额外措施,入参均可为 Lambda
表达式:

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):利用 Lambda 表达式遍历集合元素;
: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 包中。

MySQL 3

个中,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会先声明一个临时变量保存自增/减之前的价,最后回到该值作为表达式的值

第一步: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

  

 

 

网站地图xml地图