JAVA学习日记

JAVA.IO的学习日记：
1.JAVA中的File类是IO包中唯一代表文件本身信息的类，不是文件中的内容，可以利用File类中的方法对文件进行创建、删除、获取文件信息等操作。其中createNewFile()方法会抛出一个异常，需要用try和catch语句将其包裹起来。
2.RandomAccessFile提供的方法可以从文件的任意位置对文件进行访问，在读取等长记录文件的时候可以节省很多时间，该类只能操作文件，不能访问设备；该类有两种构造方法，new RandomAccessFile(f,"rw")，f为需要访问的文件名称，r和w分别为以读或者写方式打开；利用skipBytes(int i)方法可以跳转i个字节；写入整形数据时用writeInt()方法；字符串调用.trim（）方法可以去除字符串中的空格；想文件中写入中文字符时，用writeChars()方法，读中文字符时用readChar()方法；
3.InputStream类的int read()方法可以一次读取一个字节的内容，当返回值为-1时表示读取结束；int read(byte[]b)方法一次读取一个字节数组的内容，返回值表示实际读取到的字节长度；int read(byte[] b，int off,int len)方法可以从输入流中读取len个长度的字节数据从下标off开始依次存放到字节数组b中，返回值表示读取到的字节长度；包装类中long skip(long n)方法可以跳过n个字节的长度，返回的值是跳过的长度；int available()方法可以检查流中有无数据，返回值为当前流中的可读字节数；当程序要求实时读取文件中的数据时，可创建一个线程调用read方法，这样可节省CPU资源。void mark(int readlimit)用于包装类中，用于标记当前位置；void reset()用于让指针返回mark方法设定的位置；JVM只会回收程序产生的垃圾，不会回收程序运行时系统产生的一些资源。所以需要调用.close()方法从程序内部关闭因运行而使系统产生的资源。InputStream类的输入流是对于程序而言的，也就是从外部向程序中输入。
4.OutputStream类是相对于外部文件的输出流，该类的void write()方法可以向外部文件写入数据；void flush()方法可以将内存缓冲区中的数据清空并立即写入到外部设备中；
5.创建FileInputStream类的对象时，指定文件必须存在并且可读；创建OutputStream实例对象时，指定文件可以不存在，若存在则不能不其他应用程序打开。
6.Reader和Writer类可以对字符流进行处理，大多用于文本文件的访问；
7.PipedInputStream类和PipedOutputStream类用于在两个线程之间建立管道通信；一个线程可以使用PipedInputStream类从另一个线程使用的PipedOutputStream类中读取数据；

看完了JAVA网络编程部分，学习到了以下知识点：
1、JAVA中是通过发送SOCKET的方式来实现网络通信的。DatagramSocket类的构造函数有无参数，有端口参数，有端口和IP地址参数三种。它的Send和receive方法中都需要一个DatagramPacket对象作为参数。对于DatagramPacket类，当接收数据包时，采用无IP地址和端口号的构造函数，当发送数据时，采用有IP地址和端口号的构造函数，需要发送的数据存在byte[]buf数组中。并可以调用getInetAddress和getPort等方法获得DatagramPacket对象的属性。IP地址可以调用InetAddress.getByName()方法将其转换为InetAddress类型的参数。操作完成后需要调用close()方法将Socket流关闭。一个中文字符占用两个字节，所以使用中文字符串时应先调用.getBytes()方法将其转换为字节数组
2、通过编写一个UDP网络聊天软件复习了GUI的构造和事件处理，并加深了对网络编程的理解。
3、TCP协议是面向连接的通信协议，有纠错机制，不会造成数据包的丢失；UDP协议是面向无连接的通信协议，没有纠错机制，有可能造成数据包的丢失；
4、了解了私有IP通过网关代理上网的原理。网关通过转发映射记录表的映射关系，将数据包转发给外部或内部网络上的计算机。转发映射记录表可以由内部计算机向外部网络上的计算机发送数据包时建立，也可以由自己手动配置静态的映射表。外网的计算机只能看到网关的IP地址而不能看到内网计算机的IP地址。
5、TCP网络程序的编写，ServerSocket类有四种构造函数，backlog参数为当服务器处于忙碌状态时允许等待的客户数量，默认值为50。最好使用指定了端口号的构造函数。调用ServerSocket类中的accept()方法可以返回一个与客户端连接的Socket对象。可使用windows自带的telnet程序测试服务端程序。
6、使用netstat命令可以查看当前被使用的端口号。
7、ObjectInputStream和ObjectOutputStream类可以包装底层网络字节流，从而在TCP服务器和客户端之间传递对象。

JAVA基础加强视频学习笔记：

1、在eclipse中调试程序，可以先在行的前面设置一个断点，然后右键debug as转换到Debug透视图；这时若需要看某个变量的值可以右键watch；

2、JavaRuntimeEnvironment只能向下兼容，不能向上兼容。如用1.5的运行坏境运行1.6编译出来的程序就会出错；

3、在eclipse中可以在首选项->java->Editor->Templates中配置模板。

4、在eclipse中导入一个工程的方法：File->Import->选择工程所在的目录，若导入工程后安装的JDK目录与工程的JDK目录不一致可在工程上点击右键->Build path->Configure

Build path->配置相关参数。

5、用import static 包名.类名.方法名；可以静态导入一些静态的方法。

6、如果方法中需要使用的参数不定，可以使用可以变参数，用法是在方法中的最后一个参数使用"参数类型 ... 变量名"，如在一个累加方法中：
public int add(int a,int... args){
int sum=a;
for(int i=0;i<args.length;i++){
sum+=args[i];
}
return sum;
}

7、for循环增强，使用方法：for(变量类型 变量名：集合变量名){...} 例如：
public static int add(int a,int... nums){
int sum=a;
for(int num : nums){
sum+=num;
}
return sum;
}
其中的nums必须先在方法add()中定义，集合变量可以是数组或者实现了Iterable接口的集合类；

8、自动装箱：当把一个数直接付给一个Integer对象时叫自动装箱，如 Integer i1=15；如有Integer i1=15;Integer i2=15;System.out.println(i1==i2);输入值为ture(因为该

类运用了“享元设计模式”，当数字在-128~127时，多个引用指向一个数字对象)；

9、享元设计模式：当有很多个对象拥有很多共同的属性时，可以把这些对象的共通属性整合为一个对象，称之为内部状态；把这些对象的不同属性作为方法的参数传入，称之为

外部状态；

10、若自定义了一个枚举类，把构造函数设为private,在运用该类时只能使用该类中已经创建的对象，而不能自行创建该类的对象。定义枚举的方法：public enum 枚举名{枚举

变量}；一个枚举相当于一个类，每个枚举变量都相当于这个类中的一个对象；调用枚举变量的ordinal()方法可得到该变量在枚举中的排位；
“枚举类”中的valueOf("String")方法可以将String转换成相应的枚举对象；value()方法可以返回一个数组，该数组中包含了所有的枚举变量；
当给枚举定义构造方法时，构造方法必须放在元素列表的后面并且构造方法必须设置为private；如:
public enum WeekDay{
SUN,MON,TUE,WED,THI,FRI,SAT;
private WeekDay(){

}
}
在定义枚举时，还可以让元素类表中的元素选择使用哪个构造函数，在元素后面跟上对应的参数即可如：
public enum WeekDay{
SUN(0)//使用了带参数的构造函数,MON(1)//使用了带参数的构造函数,TUE(2)//使用了带参数的构造函数,WED,THI,FRI,SAT;
private WeekDay(){

}
private WeekDay(int a){

}
}
定义带抽象方法的枚举时，可以用内部类来实现元素的创建。如：
public enum WeekDay{
SUN(0){
public WeekDay nextDay(){
return MON;
}
},
MON(1){
public WeekDay nextDay(){
return TUE;
}
},
TUE(2){
public WeekDay nextDay(){
return WED;
}
},
WED(3){
public WeekDay nextDay(){
return THI;
}
},
THI(4){
public WeekDay nextDay(){
return FRI;
}
},
FRI(5){
public WeekDay nextDay(){
return SAT;
}
},
SAT(6){
public WeekDay nextDay(){
return SUN;
}
};
private int a;
private WeekDay(int i){
this.a=i;
}
public abstract WeekDay nextDay();
}

11、类编译之后变成字节码，得到字节码的方式有三种：1、调用对象的getClass()方法可以得到该类的字节码；2、在程序中用类名.class的方式；3、用Class.forName("java.

包名.类名")的方法；用Class.isPrimitive方法可以判定一个类的实例对象是不是基本数据类型，Int.class==Integer.TYPE的结果是ture,因为Integer.TYPE将该类包装的原始数

据体现出来了；数组实例对象的判定方法是用Class.isArray();

12、JAVA反射就是将每个JAVA类中的各种组成部分映射成相应的JAVA类。Constructor类代表某个类中的一个构造方法，得到某个类的所有构造方法：
Constructor [] constructor = Class.forName("该类的包名.类名").getConstructors();
得到某个类的某一个构造方法：Constructor constructor = Class.forName("该类的包名.类名").getConstructor(该构造方法构造出来的类型,如：StringBuffer.class);通过

得到的构造方法可以实例化一个对象，例如：
Constructor constructor=String.class.getConstructor(StringBuffer.class);
String str=(String)constructor.newInstance(new StringBuffer("abc"));//由于每个类都有构造方法，编译器不知道constructor是哪个类的构造方法，所以需要强

制类型转换；使用newInstance(参数)时，参数类型必须跟使用getConstructor(参数)时的参数类型一致。如以上语句中若将String str=(String)constructor.newInstance(new

StringBuffer("abc"))改成String str=(String)constructor.newInstance("abc")则会出现错误，因为constructor是一个StringBuffer类型的构造函数，而传递的是一个String

类型的参数"abc".

13、Field类可以获得字节码里面的变量，具体应用如下：
import java.lang.reflect.Field;
class Position{
private int x;
private int y;

public Position(int x, int y) {
super();
this.x = x;
this.y = y;
}

}

class Testing{
public static void main(String [] args) throws Exception{
Position pt= new Position(3,5);
Field fieldx = pt.getClass().getDeclaredField("x");//getDeclaredField()方法可以获得类中所有声明过的变量
//fieldx不是对象上的变量，而是类上的，需要要它去取某个对象上的变量的值
fieldx.setAccessible(true);//设置私有变量X为可读取，又称为暴力反射；
System.out.println(fieldx.get(pt));//取出对象pt中的X的值

}
}

14、将一个已知字符串中的'b'改成'a'，具体实现如下：
import java.lang.reflect.Field;
class Position{

public String str1 = "public";
public String str2 = "ball";

}

class Testing{
public static void main(String [] args) throws Exception{
Position pt= new Position();
changeStringvalue(pt);
System.out.println(pt.str1);
System.out.println(pt.str2);
}

private static void changeStringvalue(Object obj) throws Exception{
// TODO Auto-generated method stub
Field [] fields = obj.getClass().getFields();
for(Field field : fields){
if(field.getType() == String.class){
String oldvalue = (String)field.get(obj);
String newvalue = oldvalue.replace('b','a');
field.set(obj,newvalue);
}
}
}
}

15、不用for循环打印出一个数组中的元素列表，具体实现如下：
对于String类型的数组或者对象数组：System.out.println(Arrays.asList(String类型的数组或对象数组));

16、hashCode方法的作用：将哈希集合分成若干个存储区域，每个对象可以算出一个hashCode,按照这种hashCode将对象分别存储在对应的区域内以便提高检索的效率；

17、反射的作用，实现框架的开发；利用类加载器加载非Class文件：类名.class.getClassLoader().getResourceAsStream("绝对路径")；

18、JavaBean是一个特殊的Java类，类中方法的名字必须符合某种特定的命名规则，必须有get和set方法。若一个类有get和set方法，则可将之视作为一个JavaBean来使用；

JavaBean中若有一个getTime()的方法，则该JavaBean中必有一个叫做time的属性。

19、用内省的方式读取JavaBean对象的age属性,具体实现如下：
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

public class TestJavaBean {
private int age;

public TestJavaBean(int age) {
super();
this.age = age;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

}

class IntroSpectorTest{
public static void main(String [] args) throws Exception{
TestJavaBean tjb = new TestJavaBean(23);
String propertyName ="age";
PropertyDescriptor pd = new PropertyDescriptor(propertyName,tjb.getClass());
Method methodgetAge = pd.getReadMethod();//获得getAge方法
Object retVal = methodgetAge.invoke(tjb);//调用getAge方法后返回的值存在retVal中
System.out.println(retVal);

Method methodsetAge = pd.getWriteMethod();//获得setAge方法
methodsetAge.invoke(tjb,24);//调用setAge方法将age的值设置为24
System.out.println(tjb.getAge());
}
}

20、当需要把某些代码抽取为一个方法时，可以选中该段代码，然后右键-->Refactor-->Extract Method;

21、Map和JavaBean很相似，Map的key相当于JavaBean的属性，并且Map和JavaBean之间可以相互转换，而BeanUtils提供了这种转换的方法；

22、注解：相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，标记可以加在包、类、方法、成员变量、局部变量等上面；@Deprecated //注明当前方法已过时

@SuppressWarnings("某个警告") //注明跳过某个警告 @Override //注明是覆盖父类的方法

23、注解相当于一个写好的特殊的类，在定义注解时，用@Retention注解可以声明注解的生命周期，@Retention(RetentionPolicy.SOURCE)表示生命周期在java源文件阶段结束；

@Retention(RetentionPolicy.CLASS)表示生命周期到class文件阶段结束;@Retention(RetentionPolicy.RUNTIME)表示生命周期直到运行完之后才结束，也就是内存中的字节码中

都还有该注解；

24、反射中，类名.class得到的是字节码，也就是内存中的二进制码。

25、在注解中定义属性的方法如下：
public @interface MyAnnotation{
String color() default "red";//指定了默认值，使用注解时可以不用传递值
String value();//没有默认值，在使用注解时需要传递一个string类型的值
int [] array() default{1,2};
}

26、使用注解时，若数组属性中只有一个元素，则可省略大括号；如上例中使用注解时可以写成@MyAnnotation (color="blue",value="asd",array=3)，注解的返回值可以是基本

数据类型、String、数组、枚举、class、注解;

27、泛型的定义，在类名之后跟上<类型>，如ArrayList<String> collection = new ArrayList<String>();泛型内只能装指定类型的数据，如上例就只能装String类型的数据；

只有在JDK的api中，说明了一个类是泛型类型，该类才能使用泛型；使用泛型可以省去强制类型转换的麻烦；泛型是提供给编译器使用的，编译之后的字节码中不会在有泛型的类

型信息，所以可以利用反射的方法向编译后的泛型中添加不同类型的数据；

28、泛型的使用中，Class<?>y=Class<String>x //正确，Class<String>x=Class<?>y //错误

29、定义一个方法交换一个数组中两个元素的位置：
public <T> void swap(T [] array, int i,int j){
//<T>声明了一个任意类型的变量
T temp= array[i];
array[i]=array[j];
array[j]=temp;
}

30、写一个泛型方法，自动将Object类型的对象转换成其他类型：
public <T> T autoConvert(Object obj){
return (T) obj;
}

31、定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象：
public <T> void fillArray(T [] array,T obj){
for(int i=0;i<array.length;i++){
array[i]=obj;
}
}

32、采用自定义泛型方法的方式打印出任意参数化类型的集合中的所有内容：
public <T> void printCollection(Conlection<T> collection){
for(Object obj : collection){
System.out.println(obj);
}
}

33、若想让一个类的两个泛型方法中的泛型参数一致，则可以将该参数放在类上，如想在如下代码中让两个方法的<T>一致：
public class GenericDao{
public <T> void add(T x){

}
public <T> T findById(int id){
return null;
}
}
可以将代码改为：
public class GenericDao<T>{
public void add(T x){

}
public T findById(int id){
return null;
}
}

34、类中的静态方法不能使用泛型类型；

35、Java虚拟机中可以安装多个类加载器，系统默认的有三个类加载器，分别是：BootStrap,ExtClassLoader,AppClassLoader,每个类加载器负责加载特定位置的类；类加载器也是Java类，所以它本身也需要被加载，它是由嵌套在JVM内核中的BootStrap加载的，BootStrap不是java类，它是由C++编写的一段二进制代码；

36、JVM生成的动态类必须实现接口，该动态类只能用作实现了相同接口的目标类的代理；若目标类没有实现接口，而需要实现它的代理类则可使用CGLIB库；

37、变量名带有clazz的，说明该变量指向一份字节码；单线程的情况下StringBuilder效率比StringBuffer效率高，多线程的情况下则相反；

月薪7K之交通灯管理系统面试题破解视频学习日记：

1、需求分析：对于一个十字路口共有12条行驶路线，做交通灯时可以将12条简化成4条线路（因为一个方向的对应方向的直行跟转弯是跟该方向同时进行的），分别是从南向北直行，从南像西转弯，从东向西直行，从东向南转弯，每个方向的右转是随时都可以转的，可以将其看为一直是绿灯，而不考虑车是从哪个方向来的，从而简化编程模型。

2、面向对象的分析：该系统中应该有红绿灯、灯的控制系统、车、路线。路是装载车辆的容器，则路应该有对车辆的增减的方法。如果灯是绿色的，则减少车的数量；有一个线程在随机的时间增加车的数量。

3、一个面向对象的经验：哪个类中有数据，则该类中必须有对外提供操作这些数据的方法。

4、Executors类中的方法可以提供线程池，然后用ExecutorService的对象调用方法去执行这个线程池中的线程；

5、内部类访问外部类的成员变量可以直接用该变量的名字，也可以用外部类的类名.this.变量名的方式，当内部类访问的成员变量名字与局部变量一致时应采用后面那种方式；

6、ScheduledExecutorService提供了按时间安排执行任务的功能，可以按照不同时间来调度传进去的Runnable任务；

7、因为交通灯的数量是已知并且固定的，所以用枚举类型来定义，该枚举中应定义各条线路上的灯，并且对外提供：使灯变绿和变红的方法，当当前灯变绿或者红时，其相反路线上的灯也随之变化；判断灯当前状态的方法，返回当前灯的状态；一个私有的构造灯的方法、该构造方法应包含三个参数，即当前等对应的相反路线的灯、当前灯的下一个灯、当前灯的状态；

8、对于枚举，使用枚举名.valueOf(" ")这种方法可以得到一个名字为" "中字符串的枚举对象；

9、在灯控制器类的构造方法中，应该将某条线路上的灯的状态初始化；灯控制器中还应有一个定时器，每隔一段固定的时间就将当前灯变红，下一个灯变绿；

月薪7K之银行业务调度系统面试题破解视频学习日记：

1、工作不要轻易跳槽,要拥有一颗感恩的心，做事先做人；

2、该系统由一个取号器、三个号码管理器、服务窗口构成，其中取号器管理三个号码管理器，每个号码管理器管理对应等待客户号码的增减；所以号码管理器类中应该有增加和减少等待客户的方法；取号器类中有私有的三个号码管理器的对象并且有对外提供获得这三个对象的get方法；因为取号器只能有一个，所以取号器类只能产生一个对象，采用单态设计模式来设计该类，即把该类的构造方法设置为private，然后用一个公有的静态方法来返回该类的对象；服务窗口类中应该有一个线程不停地取不同类型的服务任务；

3、若要实现一个动态数组，则可以使用List类及其子类；集合的变量类型尽量用父类集，这样可以更为灵活，这是面向接口编程的思想；

4、两个线程访问相同数据必须让这两个线程互斥，即给这两个线程加上synchronized关键字；

5、JDK1.5之后产生一个线程可以用产生线程池的方式，即用Executors类，该类的方法可以产生线程池，线程池中可以用指定数量的线程，调用了execute()方法时则会在线程池中挑选一个空闲的线程来执行；

6、switch(变量)中的变量除了可以是char、int、byte、short，还可以是枚举类型；

7、常量应该独立的定义在一个类中，如在该系统中线程sleep的时间可以定义为：
public class Constants{
public static int MAX_SERVICE_TIME = 10000;
public static int MIN_SERVICE_TIME =1000;
}

8、在主类用三个定时器按照一定时间产生不同类型客户对象，并将客户对象储存在一个集合中；当集合不为空的时候，服务窗口从集合中取去客户对象，并打印出服务信息；