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提姆(Tim)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 引入 拉姆a
表明式升级简化匿名内部类、匿名模式,允许创制函数式接口的实例。Lambda
表达式的目标项目能还倘使阳的函数式接口,函数式接口只好讲明一个架空方法。
[1]. 创立临时对象; [2]. 赋值;

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

措施引用 ~ 构造器引用
当方法体只出同漫长代码时,可以据此智引用和构造器引用替代 拉姆da 表达式。

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

本质:利用简洁的语法创设函数式接口的实例
关于匿名内部类与 兰姆(Lamb)a 表明式的异议自行百度。

枚举

枚举类显式继承 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):批量去满意条件的因素,入参为 拉姆(Lamb)da 表达式;
 —  Stream stream(Predicate
filter):重返集合对象对应之 Stream 对象;(Stream 编程,利用 Stream
对象的汇操作简化对聚集的操作),五只流式 API:
 [I]. filter(Predicate predicate):入参为 Lambda 表明式,过滤
Stream 对象吃无符合条件的要素;
 [II]. toArray():将流 Stream 对象转换为数组;
 [III]. forEach(Consumer action):入参为 兰姆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):利用 兰姆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地图