java学习笔记

Java学习——第一章

1.java特性，面向对象（不能在类的外面定义单独的数据和函数），可移植性，解释性，健壮性，多线程

2.public static void 是main（）的权限修饰符，静态修饰符，返回值修饰符，java中必须为此三值

3.                     整数型（byte8，short16，long64，int32）八进制以0开头，十六进制以0X或0x开头

                数值型 浮点型  （float32，double64）

  基本数据类型  字符型 char16

                布尔型 true，false

4.（int）X其中char X='d',其意思是将d的无符号编码的位置显示出

5.转义字符以\开头，在printf后接(\n换行，\b退格，\r回车，\t下一个制表符，\ddd八进制字符，\dxxxx四位十六进制字符)

6.标识符，由任意顺序的字母，下划线，$和数字组成，且首位不能为数字

7java中生僻的关键字this,finally,boolean,abstract,continue,throw,throws,new,interface,do,case,stricfp,package,super,try,catch,implements,final,volatile,synchronized,instanceof,protected,import,transient,dafaule

8.声明常量的标准格式 final 数据类型 变量名称=值；

9.成员变量位于类体中，整个类中有效，分为静态变量（前面加上static，有效范围可以跨类，可以用（类名.静态变量）来调用）和实例变量。局部变量位于类的方法体中，当前代码块中有效，即两个大括号间。

10.局部变量可以和成员变量同名，此时成员变量被隐蔽

11.运算符号  /除号  %求余  *乘号 ++a表示在使用前加一， a++表示使用后加一 &（&&）与 ||或 ！非

12.位运算符号 &按位与 |按位或 ~按位取反 ^按位异或  <<左移 >>右移 >>>无符号右移

13.三元运算格式，条件式？值1：值2；

14.代码注释，单行//，多行时(不可嵌套)

15.编码规范，每条语句占一行，以英文状态下的分号结束

16，条件语句，if（布尔表达式）{                      if（布尔表达式）

             语句表达式             =                语句表达式；

                }

17.switch（表达式）{     //表达式必须为整形或字符型

  case 常量值1

   语句1

   break；         // break可省略，则程序执行到遇到break的位置

  ........

 case....                          

 default;// 若case中的常量值没有与表达式的值匹配，则执行default，若无匹配且default，则awitch不执行

 语句块n+1；

 break；

}

18.循环语句，while，do...while，for（初始化表达式；循环条件；循环后操作）

foreach语句——for（元素变量x：变量对象obj）{引用了x的java语句；}

java学习——第二章

1.String类属于java.lang包中，其内容处于双引号之内,可以用字符数组进行赋值，格式String s=new String（char a[] ,int offset,int length) offset表示开始截取的字符串位置，char的首位号是0.后两个因子可省略

2.字符串连接使用+号，获取字符串的长度str.length();  字符串查找，str.indexOf("String s")字符串首次出现的位置, str.LastindexOf("String s")最后出现的位置, str是字符串对象，s是要查找的字符串，若未查找到，则都返回-1.获取指定位置的字符，格式str.charArt(int index); index为整型值。

3.截取子字符串，格式str.substring(int beginIndex,int endIndex);其中endIndex省略时是指到末尾。

 去除空格，格式str.trim();

 字符串代替，格式str.replace(char oldChar,char newChar);其代替是所有的字符

 判断字符串的开始与结尾，格式str.startsWith(String prefix);和str.endsWith(String suffix);其值得形式是boolean。

判断字符串是否相等，格式str.equals(String otherstr);考虑大小写和str.equalsIgnoreCase(String otherstr);不考虑大小写。返回值都为boolean型。

按字典顺序比较两个字符串，格式str.compareTo(String otherstr);返回值：相等0，str位于otherstr之后为1，反之-1.

字符串大小写转换，格式str.toLowerCase();和str.toUpperCase();其中数字或非字符不变。

字符串分割，格式str.split(String sign,int limit);sign为分割符，如果定义多个分割法，可用|，例如“，|=”,limit限制分割次数，可省略。

格式化字符串，格式str.format(Local l,String format,Object ...args);其中l是格式化过程中用到的语言环境，=null时不进行本地化，可省略。format格式化字符串，args格式说明符引用的参数，可以为0.

4.时间格式话和日期格式化 Date date=New Date(); String s=String.format("%te",date);其中%te表示某一天。日期和时间格式化组合，%tF（年-月-日），%tD（月/日/年）

5.正则表达式，来检查某一字符串是否满足某一格式，例子String regex="\\w{0,}\\@\\w{0,}\\.{1}\\w{0,}";

String str="[e-mail]";if(str.matches(regex)){......}

6. 字符串生成器，格式StringBuilder s=new StringBuilder("内容");默认长度为十六个字符

追加内容s.append（content）;其中content可以是char，boolean，String，double，int或者是另一个生成器

插入内容s.insert(int offset ,arg);offset插入的位置，arg是插入的内容.

移除内容s.delect(int start,int end).

7.一维数组声明，数组元素类型 数组名字[];或数组元素类型[] 数组名字;

  分配内存空间，数组名字=new 数组元素类型[数组元素个数]；

  可等于 数组元素类型 数组名[]=new 数组元素类型[数组元素个数]；其中数组元素的个数改为数组元素时就是初始化

8.二维数组声明，数组元素类型 数组名字[][];或数组元素类型[][] 名字;

  分配内存空间，数组名字=new 数组元素类型[数组元素个数][数组元素个数]；

 可等于 type arrayname[][]={{value1,value2...}{}..{}}

9.填充替换数组元素，格式import java.util.Arrays;Arrays.fill(int[] a,int value);所有元素都用value替

 换成Arrays.fill(int[] a, int fromIndex,int toIndex,int value);

 数组排序（从小到大）Arrays.sort(object);object是要排序的数组名

 复制数组Arrays.copyOf(arr,int newlength);其中arr是要进行复制的数组，newlength是新数组的长度，不足补0.或者Arrays.copyOfRanger(arr,int fromIndex,int toIndex);

 数组查询Arrays.binarySearch(str,objectkey);或Arrays.binarySearch(str,int fromIndex,int toIndex,Objectkey)

java学习——第三章(类和对象)

1.类的实质是对象的属性和行为的载体，对象则是类抽象出来的一个实例，面向对象程序设计特点

封装性，将对象的属性和方法封装起来的载体是类，且其对客户隐藏实现细节——保护类的内部数据 

继承性，基于特定对象之间的共有属性，（父类，子类） 

多态性，同一操作作用于不同的类的实例，将产生不同的执行结果，即不同类的对象收到相同的消息时，得到不同的结果。（抽象类，接口） 

2.java中，对象行为是方法的形式定义的，对象的属性是以成员变量的形式定义的，类包括对象的属性和方法

 定义成员方法的格式  权限修饰符返回值类型方法名（参数类型 参数名）{

                      ...//方法体

                      return 返回值；

                      }

3.java中的修饰符（若无使用修饰符时，这个类预设为包存取范围）（类的权限设定会约束类的成员上的权限）

 访问包位置

 private

 protected

 public

 本类

 可见

可见 

 可见

 同包其他类或子类

 不可见

 可见

 可见

 其他包

 不可见

 不可见

 可见

4.局部变量位于成员方法内，在使用时必须进行赋值或初始化，方法执行结束后会被销毁

 关键字this，被隐式地用于饮用对象的成员变量和方法（=对象.成员变量或对象.成员方法），还可以作为方法的返回值

5.构造方法，是一个与类同名的方法，对象的创建就是通过构造方法完成的（特点，没有返回值，名称和本类的名字一样）格式 public 类名（）{...//...构造方法体}

6.被声明为static的变量，常量和方法被称为静态成员，可以在本类和其他类中调用（类名.静态类成员）

  静态方法中的规定，不可以使用this关键字和调用非静态方法，另外不能将方法体内的局部变量声明为static

7.主方法格式   public static void main(String[] args){ 

                 //方法体      没有返回值

                 }

8.对象的创建 Test test=new Test（）；第一个Test表示类名，第二个Test表示构造方法，test为对象，new创建对象（自动调用构造方法中的代码）

访问对象的属性和行为

对象的引用，格式（类名 对象引用名称；）引用只是存放一个对象的内存地址，并非对象。

对象的比较（==比较的是两个对象引用的地址和equal（）比较的是对象引用所指的内容两种）

对象的销毁，情况为对象引用超过其作用范围和对象的赋值为null，但其垃圾回收你对new操作创建的

另外可使用finalize（），只是在使用前需要先在类中定义

System.gc()强制启动垃圾回收器

java学习——第四章（包装类+数字处理类）

1.java不能定义基本类型对象，为了能将其作为对象处理，并能连接相关的方法，java为每个基本类型提供了包装类。

2.Integer，构造方法 Integer number=new Integer(int number);或Integer number=new Integer(String str);

常用方法,bytevalue()以byte型为返回值，intValue()..,compareTo()，equal（）比较两个值大小，只是返回值类型不同，toString()返回此值的String对象，vlaueOf(str)返回此值的integer对象， parseInt(str)返回此字符创中的数字的等价整数值。toBinaryString(),toHexString(),toOctalString(),返回2.8.16进制的字符串。

常量,MAX_VALUE,MIN_VALUE,表示最大最小取值，SIZE以2进制补码形式表示其比特位数,TYPE表示基本类型int的Class实例

3.Long，Short，Byte,Double,Float和Integer类似

4.Boolean常量TRUE,FALSE,SIZE，Character常用方法，isUpperCase（ch）判断字符是否为大写，isLowerCase（ch）,常量CONNECTOR_PUNCTUATION....

 

5.数字格式，import java.text.DecimalFormat;导入包

DecimalFormat s=new DecimalFormat(pattern);String output=s.format(value);

 或者 DecimalFormat s=new DecimalFormat();s.applyPattern(pattern);String output=s.format(value);

pattern的样式字符，0（该位不存在则显示0），#（存在显示，不存在不显示），%（百分号），\u2030(千分号)s.setGroupingSize(大小)；设置数字分组的大小

6.数字运算（Math类，且都被定义成static）调用方法Math.数学方法 Math.PI,Math.E

常用数学运算方法

三角函数  Math.sin/cos/../atan（double a）;Math.toRandians/toDegrees(double a)转成弧度/角度

指数函数  Math.exp/log/log10/sqrt/cbrt(double a);Math.pow(double a,double b);

取整函数  Math.ceil大于等于a的最小整数/floor小于等于/rint最接近a的整数（偶数优先）/round加上0.5后小于等于的最大整数（double a）

取最大值，最小值，绝对值  Math.max(a,b);Math.min(a,b);Math.abs(a);

7.随机数

Math.random()(0.0<=double a<=1.0)还可以生成a-z之间的字符，例(char)('a'+Math.random()*('z'-'a'+1);

import java.util.Random; Random r=new Random();或Random r=new Random(seedvalue);  r.nextInt()

8.大数字

 import java.math.BigInteger(针对大整数>2^13-1）; BigInteger a=new BigInteger("str");

其中的一些运算 bigInstance.add/substract/muliply/divide/remainder(取余)/pow/negate(取反)/shiftLeft/shiftRight/and/or/compareTo/equals/min/max

 import java.math.BigDecimal（针对大小数）;BigDecimal b=new BigDecimal(double/String val);

运算 add/subtract/multiply(BigDecimal c)/divide(BigDecimal d除数,int e商的小数点位数,int m近似处理模式)，模式有BigDecimal。ROUND_UP/DOWN/CELLING/FLOOR/HALF_DOWN/HAVE_UP/HAVE_EVEN 

java学习——第五章（接口、继承、多态）

1.类的继承  （java中的关键字都为小写）

Class Test{  //父类

Public Test(){// SomeSentence}   //构造方法

Protected void doSomething(){// SomeSentence}  //成员方法

Protected Test doIt(){     //返回值类型为Test

Return new Test();}

}

class Test2 extends Test{  //继承父类

public Test 2(){  //构造方法

super();   //super()调用父类构造方法（不能调用父类为private的）

super.doSomething();}  //调用父类成员方法

public void doSomethingnew(){// SomeSentence}  //新增方法

public void doSomething(){// SomeSentence}  //重写父类方法（重写方法权限，只能从小到大）

protected Test2 doIt(){  //重写父类方法，返回值类型为Test2

return new Test2();}  //返回值类型必须是父类返回值类型的子类

}

在继承中还有一种特殊的重写方式，子类与父类的成员返回值，方法名称，参数类型及个数都一样，不同的是方法实现内容，成为重构

在java中，当实例化子类对象时，编译器会在子类的构造方法中自动调用父类的无参构造方法，即父类对象也被实例化。（有参构造方法并不被自动调用，依赖于super关键字显示调用父类构造方法）

final（）对对像清理时，需要确保子类的final（）最后一个动作是调用父类的final（），保证所有被清除

2.Object类（所有的类都直接或间接继承了java.lang.Object类）

Object类主要包括clone(),finalize(),equals(),toString()。另外getClass(),notify(),notifyAll(),wait()不能被重写，原因是被定义为final型。

getClass()是返回对象的类的名称，Class t3=t1.getClass();

toString()讲一个对象返回为字符串形式，实际应用中通常重写toString()方法  getClass().toString()联合

3.对象类型的转型，向上转型，从一个具体的类到较抽象类之间的转换（即子类对象直接调用父类中的方法）

向下转型时相反，如果要将父类对象赋予子类对象，需要强制转化为子类型（Test p=(Test)q;其中q为Test2）

4.instanceof判断对象的类型 格式myobject instanceof ExampleClass(myobject某类的对象引用，ExampleObject 为某个类，结果为boolean型)

方法的重载（同一个类中，允许同时存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可，返回值的不同并不可以），若只有参数个数不同，可使用不定长方法语法，返回值方法名（参数数据类型...参数名）

 多态，使用父类类型的引用指向子类的对象，该引用只能调用父类中定义的方法和变量，如果子类重写了父类中的一个方法，那么调用这个方法时将调用子类中的方法，变量不能被重写，重写只只对于方法

5.抽象类（抽象类不可以实例化对象）

格式 public abstract class Test(){ abstract void Test();//定义抽象类方法}

6.接口（是抽象类的延伸，为了使用draw（）而不耽误继承图形类）

格式 public interface drawTest{ void draw();//接口内德方法省略abstract}

一个类实现一个接口的语法，public class a extends b implements drawTest{....//}

7.java中不允许多重继承，但是接口可实现多重继承

格式 class 类名 implements 接口1，接口2，....,接口n

java学习——第六章（类的高级特性）

1.包的使用可以有效的管理繁杂的文件，解决类的重名问题（同一个包中的类相互访问不需要制定包名）

定义类的包名 格式 package 包名;（包得命名都必须为小写）

导入类包 import 包名.*;//指定包中的所有类。 import 包名.类名;//指定包中的类。（子类需要单独导）

改变编译后类文件产生的位置，在DOS下， javac -d./bin/./com/wsy/*.java

导入静态成员 import static 静态成员；

2.final变量一旦被设定后就不会改变其值（声明时需要赋值），final static 则在内存中开辟一段固定不变得空间。final方法不能背覆盖，private 则无需再定义一个final。final 类名{} 定义此类不可以继承和改动，此类中的所有方法被隐式的设置为final，但成员变量可以被定义为final和非final

3.内部类

成员内部类，在一个类的内部还有一个类，内部类可以随意使用外部类的成员方法和变量，即使被private修饰

内部类的实例一定要绑定在外部类的实例上，如果从外部类初始化内部类对象，那么内部类就会绑在外部类上.

内部类的成员只能在内部类的范围使用，如果使用内部类对象，则可使用内部类成员。

如果在内部类和非静态方法之外的实例化内部对象，则需要使用 外部类.内部类  的形式指定，例如Outer o=new Outer(); Outer.Inner in=o.new.Inner() ；生成一个内部类对象。内部类可用 static、protected 和 private 修饰；而外部类只能使用 public 和 default；

内部类中访问实例变量：this.属性或直接引用属性。若重名时，在内部类访问外部类的实例变量：外部类名.this.属性。【Outer.this.属性】

4.在内存中所有对象被放置在堆中，方法和方法中的形参或者是局部变量放在栈中

5.局部内部类，在方法中定义的内部类。不能用 public、protected 和 private 进行声明，其范围为定义它的代码块；可以访问局部变量（含参数），但局部变量必须被声明为final

6.匿名内部类，是一种特殊的局部内部类，它是通过匿名类实现接口。

格式，return new A(){...//内部类体}；编译后产生外部类名$序号 为名的class文件

7.静态内部类，在内部类不需要访问外部类的非静态成员时，应该使用静态内部类，内部类声明为static。

特点，如果创建静态内部类的对象，不需要其外部类的对象。

8.内部类和其他类一样可以被继承，只是复杂一些，需要设置专门的语法。extends classA.classB

某些类继承内部类时，必须给予这个类一个带参数的构造方法，并且构造方法的参数为需要继承的内部类的外部类引用，同时在构造体中使用a.super()语句。

java学习——第七章（异常处理）

1.java的异常捕获结构由try，catch，finally组成，

try{              //存放的是可能发生异常的java语句 ，发生异常时调用catch语句

//程序块代码}

catch（Exceptiontype1 e）{ //用来激发被捕获的异常 执行完catch，继续执行其后的语句，不影响整个程序的执行，Exceptiontype1是try传给catch的变量类型，e是变量名

// 对Exceptiontype1的处理}  （getMessage()错误性质,toString()异常类型和性质,printStackTrace()类型，性质，栈层次，位置)

catch ...

finally{        //异常处理结束部分最后执行部分（不可少）

//程序块}

2.自定义异常 抛出异常的throws new MyException（“”）

3.运行异常类，RuntimeException异常是程序运行过程中产生的异常，java中每个包都定义了异常类，且都是Throwable类的子类，其有两个派生子类，分别是Exception（非致命性类，可以通过捕获处理使程序进行）和Error（描述java运行系统中的内部错误及资源耗尽错误，比较严重）

java学习——第八章（Swing）

1.依赖于本地平台的组件成为重量级组件，反之成为轻量级组件，Swing就是轻量级组件（可插入外观组件）

2.Swing层次关系，Swing中大多数GUI组件是java.awt.Component类的子类。java.swing.JComponent类是Swing存放各种特性的组件，包括设定组件边界，GUI的自动滚条等。Swing中最重要的父类是java.awt.Containter类，而其最重要的两个子类是java.awt.Window和java.awt.Frame。

3.窗体

JFrame窗体  构造方法形式 public Jframe（String title//可省略）

格式JFrame jf=new JFrame(title); Container container=jf.getContentPane();  调用getContentPane()将窗口转换成一个容器，在容器中管理组件

container.add(jl);  container.setBackground(Color.white); jf.sevisible(true); jf.setSize(宽，高)；

jf.setDefaultCloseOperation(WindowConstant.EXIT_ON_CLOSE);//关闭窗口形式，还有DO_NOTHING_ON_CLOSE,

DISPOSE_ON_CLOSE,HIDE_ON_CLOSE

JDialog窗口（对话窗口，继承java.awt.Dialog类），同样需要调用getContentPane()将窗口转换成一个容器

构造方法形式 public JDialog（frame f, String title,boolean model//均可省略）,f为父窗体

其他的功能语句如同JFrame

4.标签组件与图标

标签（父类JComponent）简单的显示文本或图片 格式public JLable(String text,Icon icon,int aligment)分别对应于 文本，图标，文字对齐方式，任意几个可省略

图标 public int getIconHight()/getIconWidth() 获取图标的长宽

public void paintIcon(Component arg0,Graphics arg1,int arg2,int arg3)实现指定位置画图标

使用图片图标（javx.swing.ImaginIcon） public ImageIcon(Image image//图片,Strign description//描述)

public ImageIcon(URL url//计算机网络上的图标，位置应该在类的文件夹下)

为标签设置图片 标签名.setIcon(图片名)

5.常用布局管理器

绝对布局 setLayout(null);取消布局管理器 setBounds(int x,int y,int height,int width);

流布局管理器，组件像流一样从左到右摆放，直到沾满此行的空间，默认情况是剧中public FlowLayout(int alignment//0左1中2右,int horizGap,int vertGap//组件之间的水平垂直距离)，参数都可省

边界布局管理器，默认不指定窗体布局的情况下，Swing的布局模式是BorderLayout，将容器分为东西南北中五个区域，使用容器名.add(bordei，new JButton（buttonName[i]）) borderi=BorderLayout.NORTH/SOUTH...

网格布局管理器（将容器划分为网格，组件按行和列排列，大小一样，左上角开始）

public GridLayout(int rows,int columns,//行列数int horizGap,int vertGap//行列间距),后2参可省略

后三种模式使用，setLayout(new Flowlayout()/BorderLayout()/GridLayout())

6.常用面板（必须被添加到容器里）

JPanel面板 JPanel p=new JPanel(new GridLay(1,1,5,2));p.add(new JButton("1"));容器.add(p);

JScrollPane面板（较小的窗体中显示带滚动调的面板，且只放一个）

JTextArea ta=new JTextArea(20,30);//文本区域组件JScrollPane sp=new JScrollPane(ta); 容器.add(sp);

7.按钮组件

 提交按钮 public JButton(String text,Icon icon)任意个可省略

jb.setEnabled(false/true)按钮是否可用，jb.setIcon(icon),jb.setHideActionText(false)控件上的文字显示，jb.setToolTipText("文字")提示文字，jb.setBorderPainted(false)按钮边界不显示，jb.setMaximumSize(new Dimension(宽，高))按钮的最大值设定，jb.addActionListener(new ActionListener(){...});按钮监听事件

单选按钮（其许多方法都是AbstractButton类的方法）

格式 public JRadioButton(String text,Icon icon,Boolean selected),其中均可省略

按钮组 ButtonGroup group=new ButtonGroup();group.add(新创建的单选按钮)；

复选框组件 格式 public JCheckBox(String text,Icon icon,Boolean selected),其中均可省略

8.列表组件

下拉列表框组件public JComboBox(ComboBoxModel dataModel/Object[] arrayDate数组/Vector vector/省略)

一般将下拉选项封装为ComboBoxModel，ComboBoxModel为接口，代表一般模型，可自定义一个类实现该接口

例如 class MYComboBox extends AbstractListModel implements ComboBoxModel{}，getSize（）返回列表长度，getElementAt(int index)返回指定索引处的值

列表框组件public void JList(ListModel dataModel/Object[] listDate/Vector ListDate) 类似于下拉

9.文本组件

文本框组件public JTextField(Document docmodel,String text,int Fieldwidth/文字长度),其中均可省略

密码框组件public JPasswordField(Document docmodel,String text,int Fieldwidth/文字长度),其中均可省

jp.setEchoChar('#')设置回显字符。

文本域组件public JTextArea(Document doc,String text,int rows,int columns),其中均可省略

jt.setLineWrap(true)使文本域自动换行

10.常用监听事件器（事件源，事件，监听程序）

 事件名称

 事件源

监听接口 

 添加或删除监听器

 ActionEvent

 JButton，JList，JTextFiel等

 ActionListener

 add/removeActionListener（）

 FocusEvent

 Componment以及其派生类

 FocusListener

 add/removeFocusListener（）

java学习——第九章（集合类）

1.常用List、Set（Collection接口）Map集合 

 数组

 长度固定

 数据类型数：数据

 集合

 长度可变

 存放对象的引用

2.构成Collection的单位被称为元素，Collection接口提供了各种方法，List和Set可以直接使用

add（Object）,remove(Object),isEmpty()判断集合是空,iterator()迭代器,size()元素个数

iterator()遍历集合类的标准访问方法，从而避免向客户端暴露集合的内部结构，Iterator it=list.iterator();//创建迭代器 i.hasNext()//判断下一个是否为零 String str=it.next()获取集合中的元素

3.List集合包括List接口和其所实现的类，允许集合中的元素重复，元素的顺序就是对象插入的顺序。List接口实现了Collection接口，还有两个重要的，get(int index) set(int index,Object obj)

 ArrayList

 可变数组

快速随机访问 

 否

  允许null

 LinkedList

 链表结构保存

 不能

插入删除效率高 

 

4.Set集合中对象不按特定顺序排序，不允许有重复元素

 HashSet

实现Set接口 

不保证迭代顺序 

 允许null

 TreeSet

 还实现java.util.SortedSet

 自然顺序递增或迭代

 

TreeSet新增方法，first/last()返回Set中第一个或最后一个元素，comparator（）返回对Set元素排序的比较器，headSet/tailSet(Object obj)返回一个新的Set集合，包含obj之前/后的元素，subSet(object from,object to)

5.MAP集合，MAP没有提供Collection接口，其提供的是key到value的映射，且单一映射

提供方法，put（key k,value v）集合中添加key和对应的value,containsValue(0bject key/value)集合中含指定的值返回true,get(Object key)存在的key所对应的值,keySet()集合中所有键对象形成Set集合,values()

 HashMap类

基于哈希表 

 快速添加和删除

允许null 

 TreeMap类

 对象存在一定顺序

 差一些

 

java学习——第十章（I/O输入输出）

1.流是一组有序的数据序列，分输入流/输出流，这些类都放在java.io包

输入流（父类InputStream,Reader）一般提供方法（并不是所有的子类中都支持其下的方法）

read（）输入流中读取数据的下一个字节返回0-255int字节值，read(byte[] b)返回字节值，mark(int readlimit)当前到readlimit参数之前的字节数，reset（）输入指针返回到当前的标记处，skip(long n)跳过n个字节，返回实际跳过的字节数，markSupported（）流支持mark和reset操作返回true，close（）关闭输入流

输出流（父类OutputStream,Writer）提供的方法类似上面

write（byte[],int off,int len），flush(0,close()

2.File类，io包中唯一代表磁盘文件本身的对象，可实现创建，删除，重命名文件等，可获得文件的一些属性

文件创建 File file=new File("d:/1.txt")/("d:/doc","2.txt")/(D:/doc/,"3.txt");

文件删除 file.delete()

文件信息获取 getname(),canRead(),canWrite(),exits(),length()文件长度,getAbsolutePath()绝对路径,getParent()父路径,isFile()文件是否存在,isDirectory(),isHidden(),lastModified()

3.文件输入输出

FileInputStream(String name/File file) 从文件中读出内容，FileOutputStream()向文件中写入数据，用法一样，且此类用法不能指一个打开文件（这两个类只提供对字节或字节数组的读取方法）

FileReader(),和FileWriter()是字节流的读取，FileReader流顺序的读取文件，只要不关闭流，read（）将读到源的末尾或关闭

4.带缓存的输入输出流（缓存是I/O的一种性能优化，可使用skp(),mark(),reset()等方法）

BufferedInputStream(InputStream in,int size)size可省略，省略时是一个32字节的缓存流，BufferedOutputStream（）的用法类似，只是有一个flush()方法可以将缓存中的数据强制输出完，类似刷新

ButteredReader和ButteredWriter还可以行为单位输入输出，ButteredReader提供的方法read(),readLine(),ButteredWriter（）提供方法为，write（String s,int off,int len）,flush(),newLine(),返回void型

5.数据输入与输出流（不再关心数值应当是什么字节）

DateInputStream(InputStream in)方法readUTF()

DateOutputStream(OutputStream Out)，writeBytes(String s),writeChars(String s),writeUTF(String s)

6.ZIP压缩输入输出（需要找到目录进入点）

zip压缩文件结构:一个zip文件由多个entry组成,每个entry有一个唯一的名称,entry的数据项存储压缩数据。

压缩ZipOutputStream(OutputStream out);常用方法putNextEntry(ZipEntry e),write(byte[] b,int off,int len),finish(),setComment(String comment),

解压ZipInputStream（InputStream in）常用方法read(byte[] b,int off.int len),avivable(),closeEntry(),skip(long n),getNextEntry(),createZipEntry(String name)

java学习——第十一章(反射)

1.java的反射机制，可以使程序员更深入的控制程序的运行，如在程序运行时对用户输入的信息进行验证等

java的反射机制还可以在程序中访问已经装载的对象的描述，实现访问检测和修改对象本身信息的功能，在java.lang.reflect包中

2.getPackage()/报路径，getName()/类名称，getSuperclass()/继承类，getInterfaces()/实现接口，getClasses()/getDeclaredClasses()/内部类，getDeclaringClass()/内部类声明

3.访问构造方法，getConstructors(Class<?>...parameterTypes),getDeclaredConstructors(Class<?>...parameterTypes),两者的参数都可省略且s去掉，将返回Constructor类型的数组或对象，但前者只能是对权限为public的构造方法，访问指定的构造方法 A.getDeclaredConstructor(参数)

Constructor常用的方法，isVarArgs(),getParameterTypes(),getExceptionTypes(),newInstance(参数）,setAcessible(boolean flag),getModifiers()其中可以通过解析getModifiers()方法得到的修饰符信息，以下是一系列用来解析的静态方法，isPublic/Protected...Final()

4.访问成员变量,getFields(String name),getDeclaredFields(String name),两者的参数都可省略且s去掉，将返回Field类型的数组或对象，但前者只能是对权限为public的构造方法，访问指定的成员变量object.getDeclaredField(成员变量名)，以下是Field提供的常用方法getName/Type(),get(obj),set(obj,value),getInt/Float/Boolean(obj),setInt/Float/Boolean(obj,value),setAcessible(bool flag),getModifiers()

5.访问方法,getMethods(String name,Class<?>...parameterTypes)，getDeclaredMethods(String name,Class<?>...parameterTypes)两者的参数都可省略且s去掉，将返回Method类型的数组或对象，但前者只能是对权限为public的构造方法，访问指定的成员变量A.getDeclaredMethods(方法名，参数)，气体够的方法如下

getName(),getParameterTypes(),getReturnType(),getExceptionTypes(),invoke(),isVarArgs(),getModifiers()

6.Annotation功能可用于类，成员变量，方法，参数等声明中，不影响程序，只会对编译器警告等辅助工具影响

定义 public @interface MemberAnnotion{String value()/default"默认构造方法";Class type();/可用的成员类型primitive，enumerated，annotion等型}

在定义Annotion类型，还可以设置其使用类型。

@Target(ElementType.ANNOTATION_TYPE/TYPE/CONSTRUCTIOR,FIELD/METHOD/PARAMETER/LOCAL_VARIABLE-PACKAGE/省略）

设置有效范围

@Retention(RetentionPolicy.SOURCE/CLASS/RUNTIME/省略默认为CLASS)

使用@MemberAnnotion（参数名/参数名=值）

7.访问Annotion信息

isAnnotationPresent()判断是否添加了指定类型的Annotion,getAnnotion()用来获得指定类型Annotion ,getAnnotions()获得所有类型的，getParameterAnnotions()只存在Constructor和Method中，用来获得添加了Annotion的参数，并以二维数组返回，顺序同声明顺序

java学习——第十二章（枚举和泛型）

1.枚举类型，可以取代以往常量的定义方式（通常将常量封装在类或接口中）

public enum Constants{a,b,c}使用常量时Contants.a表示

将常量放在枚举内public class ContntsTest{enum contants2{a,b}}

2.枚举除了具有参数检验外，还可以看做是一个类，他继承了java.lang.Enum类，定义一个枚举时，它的成员都可以看做枚举类型的实例，且默认被final，public,static修饰,其方法有

values()/枚举类型成员以数组形式返回，valueOf()/将普通字符串转换成枚举实例，compareTo()/比较两个枚举定义时的顺序，ordinal()/得到枚举成员的位置索引

3.枚举类型中可以添加构造方法，但必须为private修饰

当然也可以在枚举成员设置方法

枚举类型提供了一种友好的定义变量方法，枚举了某种数据可能的所有值

4.泛型，实质上就是使程序员定义安全的类型。语法:类名<T>,T为类型的名字。使用时，类名<T> 函数=new 类名<T>（）；

常规用法：类名<T1,T2>/定义多个类型。还可以定义泛型时声明数组类型，但不可以用其建立数组实例。可以使用K，V两个字符代表容器的键值和其对应的具体值。常用的被泛型化的集合类ArrayList<E>,HashMap<K,V>,HashSet<E>,Vector<E>

5.泛型的高级用法

 限制泛型可用类型

class 类名称<T entends 某类或接口> 

没有则对表所有 

 

 使用泛型通配符

 泛型类型<? extends List> a=null

 作用是限制这个泛型类型实现或继承某个接口或类的子类

使用通配声明的名称实例化，不能加入新的信息，只能获取或删除 

 继承泛型类，实现其接口

 泛型的类或接口也可以被继承与实现

 

 

A<?super List> a=null;对象a只接受List接口或其上层父类类型

java学习——第十三章(多线程)

1.多线程：java语言提供并发机制，程序员可以在程序中执行多个线程，每个线程完成一个功能，并且与其他的线程并发执行，这种机制称为多线程。

Thread类（java.lang.Thread）,语法public Thread(String threadName/可省略);完成真正功能的代码放在类的run()方法中，然后同时调用Thread类中的start()方法执行线程，也就调用了run（）。

Runnable接口(java.lang.Runnable),语法public class Thread extends Object implements Runnable。实现Runnable接口的程序会创建一个Thread对象，并将Runnable对象与Thread对象相关联，Thread有两个构造方法public Thread(Runnable r,String name/可省略)，使用Runnable接口启动新的线程的步骤（1，建立Runnable对象2，使用Runnable对象的构造创建Thread实例3，调用start()方法启动线程)。

2.线程的生命周期（七个）

出生状态：在用户使用线程实例调用start（）方法之前

就绪状态：当用户调用start方法之后

运行状态：当线程得到系统资源后

等待状态：运行状态下的状态调用Thread类中的wait（）方法，其只能被notify/notifyAll（）方法唤醒

休眠状态：当线程调用sleep（）方法，其中的参数是以毫秒为单位的。

阻塞状态：一个线程在运行状态下发出输入输出请求

死亡状态：当线程的run（）方法执行完毕时

3.线程的加入，使用join方法讲一个线程加入到另一个线程，另一个线程会等待该线程执行完后再继续执行。

线程的中断，现在不使用stop（）方法停止线程，提倡在run（）方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。

线程的礼让，yield()方法表示，它只是给出现在运行状态下的线程一个提醒，告诉它可以将资源礼让给其他线程，只是一种暗示

4.线程优先级

Thread类包含的成员变量代表线程的某些优先级，都在Thread.MIN_PRIORITY---Thread.MAX_PRIORITY间，默认条件下是Thread.NORM_PRIORITY。优先级可以使用setPriority（t）方法调整（t在1-10之间）

5.线程安全问题，必须考虑到两个线程同时存取单一对象的数据

线程同步机制，这时需要采取在给定时间内只允许一个线程访问共享资源，即是在给共享资源上加一道锁

java中的同步机制可以有效的防止资源冲突，使用关键字synchronized.语法:synchronized（object）{...}这个同步块也成为临界区，通常将共享资源放在synchronized定义的区域中

同步方法，语法：synchronized void f(){}.当某个对象调用了同步方法，该对象上的其他同步方法必须等待该同步方法执行完毕。

6。线程间的通信（使用wait(),notify(),以及notifyAll()方法实现）

sleep和wait的区别在于sleep（）方法的线程不释放锁。wait的两种使用方法

wait（time）这个同sleep（）含义一样，在指定的时间内暂停

wait（）会使线程永远的等待下去，直到notify(),以及notifyAll()方法唤醒

java学习——第十四章（网络通信）

1.网络程序设计室指编写与其它计算机进行通信的程序

网络端口并非真实的端口，而是假想中的，被规定在0-65535间，HTTP是80，FTP是21，通常0-1023的端口数用于一些知名的网络服务和应用，用户的普通网洛应使用在1024以上的端口。

套接字（Socket）用于将网络程序和端口连接起来，套接字是一个假象的装置，java中将其抽象化为类，程序员只需创建Socket对象即可使用。

2.TCP网络设计是指利用Socket类编写通信程序，分为主次（服务器程序和客户机程序）

InetAddress类（java.net.InetAddress）

getByName(String host)获取与Hos相对应的InetAddress对象，getHostAddress（）获取InetAddress对象所含IP地址，getHostName（）获取此IP的主机名，getLocalHost（）返回本地主机的InetAddress对象

ServerSocket类（java.net.ServerSocket）通过制定的端口等待网略上的套接字，构造方法

ServerSocket（int port,int backlog,InetAddress bind Address/可省略其中）

常用方法accept()/等待客户机连接，若连接创建一个套接字,isBound（）判断绑定状态，getInetAddress()，isClose()返回服务器套接字的关闭状态，close()关闭服务器套接字，bind(SocketAddress endpoint）将其绑定到特定的地址上，getInetAddress()返回服务器套接字等待的端口号

在命令行netstat -an 查看该程序的所有使用端口

3.UDP

DategramSocket（）创建一个数据包套接字， DategramSocket(byte[] buf,int offset,int length,InetAddress address,int port)创建发送数据包，发送使用DategramSocket类的send()发送

DategramSocket（int port）创建数据包套接字且绑定到某端口，DategramSocket(byte[] buf,int length)创建字节数组来接受数据包，DategramSocket类中的receive()方法接受UDP包

4.DategramSocket类

java.net包中的类DategramSocket构造方法DategramSocket(int port,IntAddress addr/可省略)

java学习——第十五章（数据库操作）

1.数据库系统组成部分：数据库，数据库管理系统(DBMS)和应用系统，数据库管理员

数据库是一种存储结构，允许使用各种格式输入，处理和检索数据库。不必每次需要数据时重新输入

特点：数据共享，减少数据冗余度，数据独立性，数据实现集中控制，数据可维护性和唯一性。

数据库的种类：层次类数据库，网状类数据库，对象数据库，关系数据库

2.结构化查询语言（SQL）

数据定义语言（DDL）

CREATE TABLE 表名 (栏位1 数据类型1，栏位2...)

ALTER TABLE 表名 add/change/drop ...

DROP TABLE 表名

数据操纵语言（DML）

SELECT 所选字段列表 FROM 数据表名 WHERE 条件表达式 GROUP BY 字段名 HAVING 条件表达式（分组条件）

ORDER BY 字段名[ASC|DESC]

INSERT INTO 表名[(字段名1，字段名2...)] VALUES (属性值1，属性值2...)

UPDATE 表名 SET 字段名=新的字段值 WHERE 条件表达式

DELETE FROM 数据表名 where 条件表达式

数据控制语言（DCL） grant revoke

事务控制语言（TCL） commit rollback

3.JDBC是一种可用于执行SQL语言的java API，是连接数据库和java应用的一个纽带

加载JDBC-ODBC桥驱动：Class.forName("sun.jbdc.odbc.JdbcOdbcDriver");

通过DriverManager的类getConnection创建连接对象：connection conn=DriverManager.getConnection("jbdc:odbc:数据源名字","user name","password");

创建SQL对象：Statement sql=conn.createStatement();

4.JDBC是底层的API。因此访问数据库时需要在业务逻辑层中嵌入SQL语句。其主要完成任务：与数据库建立一个连接，向数据库发送SQL语句，处理从数据库返回的结果。

JDBC的总体结构：应用程序，驱动程序管理器，驱动程序，数据源

JDBC驱动类型：JDBC-ODBC桥，本地API用java编写，JDBC网络驱动，本地协议驱动

5.JDBC常用类和接口

Connection接口(代表与特定的数据库的连接），其方法：createStatement(int resultSetType,int resultSetConcurrency/全省略)，prepareStatement(),isReadOnly(),setReadOnly(),commit(),roolback(),close().

Statement接口(用于在已建立连接的基础上向数据库发送SQL语句），JDBC中有3种Statement对象用于执行不带参数的简单SQL语句（Statement，PrepareStatement和CallableStatement)，其方法：execute(String sql),executeQuery(String sql),clearBatch(),executeBatch(),addBatch(String sql),close().

PrepareStatement接口（用来动态执行SQL语句），其方法：setInt/Float/Long/Double/Boolean(int index,b)setDate/String/Null(a,b),executeQuery(),executeUpdate(),clearParameters()

DriverManager类（管理数据库中所有的驱动程序）,其方法：getConnection(String url，user name,password),setLoginTimeout(),println(String message)

ResultSet接口（类似于一个临时表，用来暂时存在数据库查询操作所获得的结果集，具有指向当前数据行的指针，通过next（）方法将指针向下移动），常用方法getInt/Float..../Object(),first/last/next(),beforefirst/afterlast(),absolute(int index),isFirst/isLast(),updateInt/Float..../Object/Null/Date/Double(),getrow(),insertRow(),updateRow()

6.数据库操作（要访问数据库，先加载数据库驱动，然后创建一个Connection对象，再执行SQL语言（先通过createStatement获取Statement对象），最后销毁Connection对象，释放与数据库的连接）

连接数据库

通过java.lang包中的静态方法Class.forName("sun.jbdc.odbc.JdbcOdbcDriver");加载JDBC驱动

通过java.sql包中的类connection conn=DriverManager.getConnection("jbdc:odbc:数据源名字","user name","password");建立数据库连接

向数据库发送SQL语句

模糊查询 slect * from tb_stu where name like '张%'(_下划线代替一个字符，%百分号代替一个或若干）

预处理语句：sql=con.prepareStatement("slect * from tb_stu where id=?" )在执行预处理语句前必须设置通配符表示的值，sql.setInt(1,2)

可以通过Preparestatement类的制定参数动态对于数据表中的数据进行添加，修改，删除操作，然后executeUpdate（）方法更新