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="aaaa@111.com";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()方法更新