java学习日记 第一阶段

2015-07-21

Java语言平台的特点：

<1>跨平台半编译虚拟机（andriod 也是半编译跨平台意义不大内存消耗比较大相对ios优势不大）

<2>GC机制垃圾回收机制Garbage collection

<3>面向对象:封装继承多态

<4>健壮性：异常处理

<5>简单性：不支持多继承不使用goto语句…

workspace用于组织多个相关的project

package多个类的集合用于解决命名冲突

包的名字：>全部小写

> 具有含义https://www.360docs.net/doc/b415761741.html, 范围公司项目层、模块

类的首字母大写，自定义的数据类型

内容补充：数据类型分为两种：基本数据类型和引用类型

基本数据类型：4类8种注意：boolean是逻辑类型float用的比较少

Short char 是一个字节的11110101 int 是4字节

1Byte=8bit

引用类型：String int[] 类接口

基本数据类型和引用类型的区别

<1>存储位置不同基本在stack中引用heap中

<2>基本数据类型的存储位置是确定的

主函数

Java项目程序的启动点、

public static void main(String[] args){

}

两个项目之间的相互调用 buildpath大型的项目多用这种方式便于分工合作

alt+？是自动匹配自动提示

51cto 宅客学院有肖老师的视频 51cto毕业设计步骤

机器语言–>>汇编语言->> c(开发效率低运行效率高硬件要求低)->>c++(OO开发效率高运行效率高有指针会造成内存泄露)->>java(OO 开发效率高运行效率一般优势在于GC机制回收内存)

栈放基本数据类型和引用引用失效标记失效回收内存

OOP（object orient program）->>SOP (service orient program)->>AOP(aspect orient program)

JavaSE java standard edition 标准版

JavaEE java enterprise edition企业版

JavaMe 微型版

B/S Browser server C/S Client server

Applet container (密码加密插件) Web container（tomcat）

java项目的目录结构

src：存放源代码UserUi.java

bin：存放编译后的文件UserUi.class 字节码文件，称之为半编译，虚拟机进行动态解释，边编译，边解释。

JRE java runtime evironment JDK java develop kit jdk包含jre

javac 编译器编译.java 文件

自动编译build automatically

Clean 清除编译

java 标识符的命名规范:

<1>不以数字开头不能使关键字

<2>常量命名经常使用下划线变量不使用下划线MATH_PAI

<3>变量的首字母小写类首字母大写方法的名字首字母小写是动词

匈牙利命名法：m_intUserCount;

驼峰命名法：schoolStudentName

(变量和方法的名一致)

java中一切皆对象

基本数据类型都有包装类

https://www.360docs.net/doc/b415761741.html,ng.object 是类层次的根类即所有类的父类

基本类型–>包装类：装箱

反之：拆箱

String 引用类型字符串是常量创建之后指向对象的内容不能更改，但是指向地址可改基本类型的变量装的是具体的值引用类型变量装的是指向对象的地址

stringBuilder 线程不安全首选效率高

stringBuffer 线程安全

\n \r 换行 \转义字符

Indexof()

Split 用指定的分隔符拆分字符串例子：

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2015-07-22

变量

<1>声明：变量声明时没有内存分配

<2>初始化：一般声明的时候不要初始化new关键字分配内存空间

<3>变量的调用：作用域生命周期

局部变量：

>>定义在方法内部

>>作用域在声明所在的大括号内。

>>生命周期从变量初始化被调用开始，超出作用域会被标记为可回收，自动回收。

成员变量：类内的方法外部的非静态变量，又称为属性。

>>作用域是类内所有的方法。

>>生命周期与所在对象的生命周期一致。

静态变量：第一次调用的时候分配内存，直到程序结束。类是抽象的，对象能被销毁>>定义在类内方法外，类变量，不是属性。

>>通过类的名字.直接调用。作用域和成员变量一样。

>>通过对象调用也可以，多个对象共享一块内存，不属于某个对象。

对数组的声明和初始化

断点调试

双击左边空白处，设置断点→右键→debug

F6 单步调试

F8 从当前断点跳到下一断点，如果没有，结束调试

抽象和封装

抽象：从对象个体中提取他们的共同的特征，形成一类物体Class

对象：具体的个体——在计算机中，对象是类的实例(可以分配内存的，这个过程叫做实例化) User u //对象的声明u=new User() ///对象的实例

面向对象的提取过程

?提取所有的名词性概念——生成概念模型（需求分析阶段）

名词可以生成类或者类的属性

?找动词——提取方法

导包的快捷键ctl+alt+o

This：类的当前对象

构造方法：

（1）给必要的属性初始化把局部变量赋值给成员变量

（2）成员变量先赋值再执行构造函数。

构造方法特点

<1>方法名和类名一致（首字母大写）

<2>没有返回值

<3>一个类有多个构造方法

有参数的构造中参数传进去的是必要的信息，区别于对象中的赋值。

//把局部变量的值赋值给成员变量

//在构造方法里设置默认值

抽象的类属性不能有具体的值，除非默认属性值在构造函数中初始化

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2015-07-23

软件的要求：高内聚低耦合、

SRP：simple responsible priniple简单责任原则

OCP：Open close principle 开放关闭原则对于功能的扩展是opened 对于功能的修改时closed

Oop的三大特点是：封装继承多态

抽象是把对象共有的特征抽取成类。

封装：目的是—安全

封装的步骤：<1>属性设置成private

<2>添加set get 方法

<3>在set中过滤不合理的入参

如何设置只读属性:

<1>通过构造函数的参数给属性赋值

<2>把属性的set方法删除

用于封装的常用关键字：private public protected 默认

对象的初始化方法：

1.通过构造函数，传入参数，给必要的属性初始化，同时可以设置默认值

2.通过对象.属性的方法初始化对象

3.public void init() {}

private 关键字：只有类的内部可以调用

public 关键字：访问权限最大，类的内部对象都可以调用

注意：局部变量必须初始化，属性可以不用初始化

static 关键字：

1．常量的定义：static+final关键字

常量特点

<1>永远不会变化

<2>不会占用内存在编译的时候已经写死了，编译到源文件里，节省内存

<3> 举例子用PI 先配置，再使用，直接在源代码修改常量value

变量用final关键字赋值一次后也不能改变。所以值是否可改不是常量的专有特点。变量在编译的时候占内存。

Static变量和static方法

●静态变量：第一次调用的时候分配内存，直到程序结束。类是抽象的不分内存，

对象能被销毁

<1>类变量，不是属性。

<2>通过类的名字.直接调用

<3>通过对象调用也可以，多个对象共享一块内存，不属于某个对象

●静态方法：类方法,静态方法中只能有静态变量和方法

●静态方法和属性的关系：

<1> 静态方法可以直接调用静态属性，但是不能直接调用所在类的非静态属性。

<2> 静态方法不使用this(静态属性也不使用this)关键字。

注意：在方法内部不能够定义一个static局部变量

补充：成员变量和局部变量冲突的时候用this区别，静态变量和局部变量冲突的时候用类名.来区别。局部变量优先。

方法的重载：方法名相同参数列表不同与返回值和修饰符无关>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

2015年7月27日星期一

作业包装和equals

复习三种变量

复习了equles和==区别。对象是否相同看首地址和类型是不是相同。

Xml 可扩展性标记语言讲解见文档xml讲解

Stack和heap的区别和关系（内存管理机制pdf）

装箱与拆箱的定义作用和重要的类？(见ppt)

作用：JAVA一切皆对象。多线程，反射，哈希。多线程下基本数据类型是无法操作的，所以要包装。List是个典型的并发环境，并发环境下需要使用引用，基本数据类型办不到。为了让他按对象处理。

为什么要使用包装类？

（1）为了在各种类型的转换

（2）有时候，一个函数需要传递一个Object类型的变量，而你想传递int类型的，所以使用包装类利于传值

（3）当需要往ArrayList,Hashmap中放东西时，像Int，double这种基本类型放不进去，因为容器都是装的object的。

多线程下基本类型没有办法引用基本类型，比如说集合ArrayList，它是一个并发环境，如果往里面放int,放不进去，所以想让它当对象处理必须用包装类。

●装箱：基本数据类型转为对象类型。

int k = 100;

Integer kk = k; //自动装箱

●拆箱：对象类型转为基本类型

●包装类：Byte, Character, Boolean, Short,Integer, Long, Double, Float

组合(composite)或者聚合(aggregate)：---------has-a的关系例如：

Aggregate(by value , by reference) 班级和学生的关系(by reference 生命期不一致) 学校和班级的关系(by value 生命期一致)

父类属性提取方法：

<1>提取所有子类的共性属性和方法

父类的构造方法先执行

//通过子类，像父类传参数

Implicit super constructor Pet() is undefined. Must explicitly invoke another constructor

<2> 删除子类中的重复属性

继承：子类会继承父类的非似有的属性和方法

知识点：子类和父类之间属性和构造方法的执行顺序

<1> 子类和父类的属性同时赋初始值

<2> 先调用父类的属性赋值private double age=4;

<3> 调用父类的构造函数，给父类的属性赋值

public Pet(String name){

https://www.360docs.net/doc/b415761741.html, = name;

this.health = 70;

}

<4> 给子类的属性赋值private double age = 3;

<5> 调用子类的构造函数，给相关属性赋值【看7-27的PetGame中的dog和pet】

public Dog(String name){//子类的构造方法会自动去先调用父类同等结构的构造方法

super(name); //一定要在第一句

https://www.360docs.net/doc/b415761741.html, = name; //把局部变量的值，赋给成员变量（当局部变量与成员变量同名时，局部变量优先）

this.health = 80; //设置属性默认值

}

Dog dog=new Dog();内存只有一块，父类和子类对象都在里头

(3)重写override 子类和父类有同名同参的方法

子类和父类拥有同名同参的方法，调用时会调用子类的这个方法

编译与预编译：

预编译又称为预处理，处理以# 开头的指令，做些文本代码的替换工作。

封装的几个关键字对比：

（1）private：只有类内的方法和属性才能使用（作用域是类内）

（2）Public ：子类和对象都可以调用（从任何地方都可以调用属性和方法）

（3）Protected：子类可以直接调用父类的属性和方法（不区分包内包外）；

同一包内的对象可以调用。（Dog dog=new Dog(); https://www.360docs.net/doc/b415761741.html,="aaa";）

（4）默认：包内（对象和子类）都能调用。主要用于修饰类。仅限于包内。class Pet{} ，这样即使你做了jar包的引用，也不能使用某些类

所以调用属性或方法的三种：类内调用；对象调用；子类调用

this：对象本身；super：父。

public Cat(String name) {

super(name);

super.swim(null);

super.age = 10;

}

子类重写了父类的方法之后，Dog dog=new Dog(); t=dog.getAge(); ----调用子类的getAge()方法。

Pet pet=(Pet) dog;

T=pet.getAge(); -------------调用子类的方法，因为子类已经把父类的给覆盖了

子类可以继承父类哪些成员：非私有成员

Dog dog = new Dog("旺财");

Pet pet = (Pet)dog; ---------子转父，是安全的转换

Pet pet = new Pet("ddd");

Dog dog = (Dog)pet; -------父转子，可能会出错

if(pet instanceof Dog){

Dog d = (Dog)pet;

System.out.println("类型转换成功");

}

抽象类中可以写抽象方法：

public abstract void play(); -----非抽象类中不能写抽象方法

子类如果是非抽象类，就必须重写父类的抽象方法。

final关键字的4种使用方法：

1. 用于修饰class，使该class不能被继承

2. 方法不希望被重写，可以使用final修饰----如打好jar包的类库

3. 属性不希望被修改，用final修饰

4. final Dog = new Dog(); 锁住引用。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2015-7.28 周二

1、宠物的color属性是放在子类好、还是父类好？

有些属于子类的特有属性和行为，放在父类则透明性好，放在子类则安全性好。

问题：透明与安全。

2、抽象类的特点：不能实例化。

This与super的区别：？

（1）this代表对象自身。Super代表父类。

（2）子类和父类都同时有同名的变量（name）时，https://www.360docs.net/doc/b415761741.html,是找的是子类的name（子类父类都定义）；子类没有name的时候，https://www.360docs.net/doc/b415761741.html,调用的是父类的。

Private final String ip="10.0.1.2"; //在这里直接赋值之后，就变成了常量。

Private final String ip;//在这里定义，在构造方法里赋值，这里是变量。

Final Dog dog=new Dog("旺财");

dog.setName("缓缓");//final修饰引用类型的变量，变量的值是不变的，变量指向的对象的值是可变的

汽车租赁项目练习：

1、抽取名词性概念：汽车；租赁公司、车型、日租金；常量：别克商务、宝马550

2、抽取动词：出租单辆车、出租多辆车

3、抽象class：

4、名词不是类就是属性。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

2.015-7.30 星期四接口

1、接口：接口是对象能力的表示

类是单线继承的，不允许多重继承（使用接口达到多重继承）

2、接口的命名：

（1）按照能力的语言表示。直接命名：Swim

（2）匈牙利命名法：ISwim

（3）SwimInterface

3、接口的特点：

（1）所有的方法都强制为抽象方法

（2）一个接口中可以写多个与接口相关的抽象方法

（3）某个类实现了接口，就要重写接口中的所有的抽象方法

（4）一个类可以实现多个接口

（5）接口中不能存在属性，可以有常量

***********面向接口的编程*********************public void Swim(ISwim[] pets，Pool pool)

作业：自学enum类型。

接口与抽象类的区别：

（1）抽象类里可以有属性，接口中只能有方法和常量

（2）抽象类中可以有方法的实现---------------接口中都是抽象方法

多态：形参使用的是父类的引用，而实参传入的是子类的实现，它们执行相同的动作。

形参使用的是接口，而实参传入的是子类的实现，它们执行相同的动作，产生了不同的行为多态的本质是方法的重写技术。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2015-7-31 星期五

java.util 接口Collection< E>-----------------------------集合（动态数组）。E：element.元素，一般指https://www.360docs.net/doc/b415761741.html,ng.Object

方法：boolean add(E e)————

Size()————

https://www.360docs.net/doc/b415761741.html,ng 接口Iterable---------------------------是集合的父接口。

它的目标是：进行循环迭代。方法：iterator()---------返回一个迭代器，Iterator。

Java.util 接口Iterator< E>----------------对collection进行迭代的迭代器

方法1：boolean hasNext()--------------------------如果仍有元素,则返回true

方法2：E next（）-——————返回迭代的下一个元素

Java.util接口List ———它是一种特殊的集合；它是有序的collection（核心概念：索引）

List通过什么办法实现有序？？————通过它的实现类

1、它继承了Collection接口中的所有方法

2、自身的方法主要围绕顺序展开

E get(int index)————返回列表中指定位置的元素

Remove( int index)————移除指定位置的元素

（那么从List 指定位置remove元素后，List集合会发生什么变化？

答：将所有的后续元素向左移动（将其索引减1））

遍历法：（1）

Java.util 类ArrayList————集合的实现类-————List接口的大小可变数组的实现（1、是Lishi接口的实现2、底层数据结构是静态数组，3、数组大小可变）

默认构造方法：ArrayList() 构造一个初始容量为10 的空列表

构造方法：ArrayList( int initialCapacity) 构造一个具有初始指定容量的空列表

注意初始空间一定要分配好，不能出现反复的内存拷贝，浪费空间

Java.util类LinkedList< E >-————j集合的实现类；List接口的链接列表实现（1、是list 接口的实现；2、底层数据结构是静态链表，3、数组大小可变）

Set接口：一个不包含重复元素的的集合；最多包含一个null集合

Set接口使用示例：

1、数据库中的表是有主键的，entity与表建立影射的时候（ORM），影射记录集时常用set。

2、购物车中的商品

3、班级中学生的集合

Java.util 类HashSet————Set接口的实现类

由哈希表（实际上是一个HasMap实例）支持，无序

public boolean add(E e) --------------如果存在重复记录，则添加失败

通过add方法向List和Set中添加null元素，观察集合的size

Collections是一个工具类，它包装了对Collection集合的多种常用方法；这些方法都是static 方法；

1、泛型：在类或接口的设计时，没有指定具体的数据类型。

在具体的实现类时，可以指定具体的类型进行操作

:泛型的习惯性表示，可以使用其他字母

3、集合中的元素的顺序：一些collection是有序的，一些是无序的

练习：

●是否可以按照集合中索引的顺序查找元素？---------------不可以，因为集合中一些是有序

的，一些是无序的。

●是否可以向集合中添加重复元素-----------------------一些可以，一些不可以。

●集合中是否可以添加null元素——————一些可以，一些不可以

●比较说明ArrayList与LinkedList、HashSet、Vector、Stack这些集合类型,说明它们的异同

（1）ArrayList和LinkedList都是List集合的实现类

（2）ArrayList底层数据结构式静态数组；LinkedList是链表

（3）ArrayList的优点是便利速度快；LinkedList的插队、删除元素，操作速度快

●Boolean isEmpty()==true 与null的区别？

●ArrayList 的底层结构是静态数组，为什么大小可变？

答：它是通过内存拷贝来实现的，初始化的时候是10,如果我有11个,那么我会把那10个废弃掉，再重新初始化+10，再把之前10个内存中内容的拷贝过来，把第11个加进去

Set集合中是否可以添加重复元素？————不可以

Set集合中的元素是否有序？——————不一定

Set集合中是否可以添加null元素————可以（只能添加一个null，因为不能重复添加）

List集合中是否可以添加null元素？————可以

练习题：读取一个List< Integer>集合中的所有元素，用字符串形式输出（元素之间使用，隔开）

Collection与collections的区别？

Collections是一个工具类，它包装了对Collection集合的多种常用方法，这些方法都是静态方法。

Collection是集合类的上级接口，继承于他的接口主要有Set 和List.

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

24、GC是什么? 为什么要有GC?

GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

34、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。

equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

35、构造器Constructor是否可被override?

构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

45、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

不对，有相同的hash code。

46、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

53、你所知道的集合类都有哪些？主要方法？

最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。

Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。

69、简述逻辑操作(&,|,^)与条件操作(&&,||)的区别。

区别主要答两点：a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型

b.逻辑操作不会产生短路

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2015-8-03 星期一

java.util接口Map：类型参数：

K- 此映射所维护的键的类型

V- 映射值的类型

方法：get( Object key )返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。

这里用到了get方法，通过看它是否返回为空，判断该名字是够被注册

Map中的keySet（）方法，返回此映射中包含的键的set视图

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2015-8-4

https://www.360docs.net/doc/b415761741.html,ng 类的Exception：所有异常的父类。

使用明确的MismatchException这种异常，这样子会提示明确的错误信息，如果只是用Exception，它的提示不明确。

https://www.360docs.net/doc/b415761741.html,ng 类RuntimeException ————RuntimeException是那些可能在Java 虚拟机正常运行期间抛出的异常的超类。——————https://www.360docs.net/doc/b415761741.html,ng.NullPointerException

Try{}代码举哀中包含可能出现错误的代码，明确没有错误的代码不要写在try{}块中。

1、try{}中代码太多，影响性能

2、Try{}块中代码太多，没法明确的提示错误的位置和错误信息

3、程序一旦发生异常，就会被中断。

1、异常发生后，从异常发生的代码行中断

2、异常代码如果在try{}块中，这个异常会被try{ }对应的catch捕获，异常捕获后，不影响后面的程序继续运行。

3、异常代码如果没有在try{ }，它会被后面的try{}catch{}（即调用者）块捕获。【层层抛出】如果后面没有try{}catch{}，就会抛出给用户————这就发生严重问题了。

4、e.printStackTrace只能用于调试阶段，后期应该删除此块代码，把所有错误信息放到错误日志里。

5、反射：程序在运行时获取对象。反射的作用：找到程序运行的位置

Logger：

Logger 对象用来记录特定系统或应用程序组件的日志消息

可通过调用某个getLogger 工厂方法来获得Logger 对象

logger。

6、知识点：

使用Log4j写日志：

1、错误等级debug < info < warning

注意：只有比配置的错误等级高的信息，才能被记录

2、所有catch{}的代码块，必须用日志工具记录错误信息。Log.logger.error(e.getMessage( ))

Info的信息，记录在当前项目位置的一个文件中（文件名在log4j的配置文件中指定了log.appender.BB.File=ExceptionProject.log）

Public class Log{

//日志必须要记录在程序运行的位置

Public static Logger logger= Logger.getLogger(Log.class.getName()); //反射作用：找到程序运行的位置}

使用static,只使用一个对象，日志都写在一块内存里面。

https://www.360docs.net/doc/b415761741.html,("进入TestBiz——>>test");

异常处理的要求：

在分层的项目代码结构下，ui ——》》biz——》》dao。

底层的异常一定要记录，但是不能处理，应该抛出给上层的调用者，由它处理，（例如：dao出错，那么biz来处理关闭数据库(也可以不处理，直接抛给UI)，然后抛给UI，ui再给用户一个友好的提示，所以，最终的异常处理者是UI层）

处理方式：

（1）throw e；即二次抛出异常

Catch(Exception e){

Log.logger.error(e.getMessage);

Throw e;

}

(2)在方法的声明处：throws Exception

详情请看ExceptionProject

4、

Exception（异常）：合理的应用程序想要捕获的意外条件

Error（错误）：合理的应用程序不应该试图捕获的严重问题。（是unChecked）;

发生error错误后，程序中断。可以使用try{}catch{}进行捕获

OutOfMemerroyError：内存溢出

StackOverflowError：堆栈溢出

Checked异常和unChecKed异常：

（1）Checked异常：throw new Exception("sddddd"); 必须要用catch显示的捕获或者用throws Exception向调用者抛出的异常。

（2）unChecked异常：无须要用catch显示的捕获或者用throws Exception向调用者抛出的异常。Throw new RuntimeException("dddd")。(Exception异常中只有RuntimeException才是unChecked)

未被捕获的RuntimeException 的任何子类都无需在throws 子句中进行声明。

虚拟机正常运行期间抛出的异常的超类————所有unChecked异常都是RuntimeException 5、传统的三层架构：UI层、业务逻辑层、数据访问层

知识点：

托管资源：如自己写的类。自己的程序

非托管资源：如数据库句柄、IO的句柄等。外部资源无法用虚拟机的GC回收，必须要手动释放或关闭

（1）throw用在方法中实现，throws用在方法声明中

（2）throw只能用于抛出一种异常，throws可抛出多种异常

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2015-8-05

1、URL与URI的概念与区别

2、String path=Log.class.getResource("./").toURI( ).getPath( )获得项目当前运行路径(用于创建日志文件、创建文件夹、上传图片)

//静态变量初始化，只执行一次（而且执行顺序最早）

Public static Logger logger=Logger.getLogger( Log.class.getName( ) )

3、在静态代码块中给本类的静态变量初始化：

public static Dog dogger;

static{

Dogger=new Dog("aa");

}

静态代码块的作用：用于给本类的静态变量进行初始化

3、静态变量是类变量，与对象无关。直接使用类名调用静态变量，无需构造函数——不应该在构造函数中给静态变量初始化。

4、静态代码与构造函数的谁先执行？？静态代码块。因为静态代码块是脱离对象的，它属于类，即使你Log log=new Log( ); 它都是先调用静态代码块

5、程序执行顺序：Log log=new Log( );

1）静态变量赋值（2）静态代码块（3）成员变量（4）构造函数

public static Dog dogger = null;

public string name="aa";

6、静态方法中不能调用类的成员变量，因为属性是属于对象的，它必须通过对象来分配内存，只有存在对象时才能分配内存

7、Log.writeLof();//调用Log中的静态方法

程序执行顺序：

（1）静态变量赋值

（2）静态代码块

（3）静态方法

8、静态代码块总结：（1）静态代码块的执行顺序是静态变量初始化之后

（2）不管里调用静态代码块所在的类中的任何方法或属性，（如构造方法。静态变量），静态代码块都先执行。

（3）静态代码块只执行一次

9、线程：

进程：由操作系统管理的一块独立的内存空间。一个进程不允许直接访问其他进程的内存空间

线程：多个线程就是进程中的多条同时存在的内存访问路径——并发

多CPU的环境，才能产生真正的并发；单CPU的环境没有真正的并发，实际是时间片的模拟

启动线程：start( )

创建线程的方式：（1）继承Tread类（2）使用Runnable接口

（1）继承Thread类

一种方法是将类声明为Thread的子类。该子类应重写Thread类的run方法。接下来可以分配并启动该子类的实例。

（2）使用Runnable接口

另一种方法是声明实现Runnable接口的类。该类然后实现run方法。然后可以分配该类的实例

******************************************************************************* 知识点：

传值与传址：

传值：传入的是基本类型，通过参数传给方法，传的是值的拷贝。所以函数体内的值的变化，不会影响函数体外的值。

如果传入的是基本类型的包装类的引用，传的仍然是值的拷贝

所以函数体内值的变化，不会影响函数体外的值。

字符串作为参数传入，函数体内值的变化，不会影响函数体外的值

传址：传入的是对象的引用，通过参数传给方法，传的是地址的拷贝

如果在函数体内，改变传入地址所指向的对象数据，会影响到函数体外的对象

10、类的划分：

（1）public class Dog{ }

（2）与public class放在同一个文件，但是与所在文件的名字不一致Dog.java ——》class Test{ }

（3）内部类：public class Dog{ class Test{ } }定义在其它类的内部

（4）匿名类：Thread thread=new Tread( new Runable( ) { public void run( ){ } })匿名类用于简单代码的实现，省掉了class的声明

11、Wait()方法和notify()方法是写在一般方法内，而不是静态方法内的

Sleep()和yield()；

yield: 暂停当前正在执行的线程对象，并执行其他线程

Wait()：在其他线程调用此对象的方法或