Java初识

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 基特)= 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 类名

档案馆 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枚举类。

至于访问修饰符

档案馆 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:格式化时间、日期;
   => 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;

多态

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

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

分子方法

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

内部类

长:成员间类作为外部类的成员,能够拜外部类的旁成员

场所: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 引入 兰姆(Lamb)a
表明式升级简化匿名内部类、匿名形式,允许创造函数式接口的实例。兰姆da
表明式的目标项目能都如若显然的函数式接口,函数式接口只可以申明一个抽象方法。
[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 集合分为 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):入参为 兰姆(Lamb)da 表明式,遍历流
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):利用 兰姆(Lamb)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 包中。

档案馆 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

  

 

 

admin

网站地图xml地图