1.final关键字
final关键字在java中被称为完结器,表示最终的意思
Final能声明类、方法、属性:
使用final声明的类不能被继承
使用final声明的方法不能被重写
使用final声明的变量变成常量,常量是不可以被修改的
-
抽象类
抽象类的概念:
包含一个抽象方法的类就是抽象类
抽象方法:
声明而未被实现的方法,抽象方法必须使用abstract关键字声明
抽象类被子类继承,子类(如果不是抽象类)必须重新抽象类中的所有抽象方法
定义格式:
Abstract class className{
属性
方法
抽象方法
}
抽象类不能直接实例化,要通过其子类进行实例化
-
接口
接口是Java中最重要的概念,接口可以理解为一种特殊的类,里面全部是由全局常量和公共的抽象方法所组成
接口的格式:
Interface interfaceName{
全局常量
抽象方法
}
接口的实现也必须通过子类,使用关键字implements,而且接口可以是多实现的
一个子类可以同时继承抽象类和实现接口
一个接口不能继承一个抽象类,但是可以通过extends关键字同时继承多个接口,实现接口的多继承
-
面向对象多态性
-
多态性
多态性的体现:
方法的重载和重写
对象的多态性
对象的多态性:
向上转型:程序自动完成
父类 父类对象 = 子类实例
向下转型:强制类型转换
子类 子类对象 = (子类)父类实例
-
instanceof关键字
在Java中可以使用instanceof关键字判断一个对象到底是不是一个类的实例
8.泛型
1.认识泛型
泛型是在JDK1.5之后增加的新功能。泛型(Generic)
泛型可以解决数据类型的安全性问题,他主要的原理,是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。
格式:
访问权限 class 类名称<泛型,泛型...>{
属性
方法
}
对象的创建
类名称<具体类型> 对象名称 = new 类名称<具体类型>();
-
构造方法使用泛型
构造方法可以为类中的属性初始化,那么如果类中的属性通过泛型指定,而又需要通过构造方法设置属性内容的时候,那么构造方法的定义域之前的并无不同,不需要像声明类那样指定泛型
-
通配符
即在声明的时候指定类型为T:
Class Info<T>{
Private T key;
}
当用的时候再为其指定具体的类型(T可以被Java中的任意一种基本数据类型代替)
-
泛型接口
在JDK1.5之后,不仅仅可以声明泛型类,也可以声明泛型接口,声明泛型接口和声明 泛型类型的语法类似,也是在接口名称后面加上<T>
格式:
Interface 接口名称<泛型标识>{
}
-
泛型方法
泛型方法中可以定义泛型参数,此时,参数的类型就是传入数据类型。
格式:
访问权限 <泛型标识> 泛型标识 方法名称([泛型标识 参数名称])
集合类
-
Java集合collection
Collection是一种接口,也是List和Set的父类。
它的不同的方法详见API。
-
Java集合List
-
List接口可以存放任意的数据,而且在List接口中内容是可以重复的;
-
List接口常用子类:
ArrayList采用异步处理方式,性能高,属于非线程安全;
声明格式如下:
List<Type> listName = new ArrayList<Type>();
添加数据:
ListName.add(Object);
Vector采用同步处理方式,性能低,属于线程安全;
声明格式如下:
List<Type> listName = new Vector<Type>();
添加数据:
ListName.add(Object);
输出格式都是利用循环输出:
For(int i = 0;i < listName.size(); i ++){
System.out.println(ListName.get(i));
}
-
常用操作:
判断集合是否为空:boolean isEmpty();
查找指定的对象是否存在:int indexOf(Object o);
其他方法详见API。
-
Java集合Set
-
Set接口中不能加入重复元素,但是可以排序。
-
Set接口常用子类
散列存放:HashSET
Set<Type> SetName = new HashSet<Type>;
有序存放:TreeSet
Set<Type> SetName = new TreeSet<Type>;
添加数据都是:
SetName.add(Object);
输出格式都是:
System.out.println(s);
-
Java集合Iteration
-
集合输出的标准操作
标准做法:使用Iteration接口
-
操作原理
Iteration是专门迭代输出接口,迭代输出就是将元素一个个进行判断,判断其是否有内容,如果有则把内容取出。
-
实例化操作:
Iteration<Type> IterationName = collectionName.iteration();//此处可以是任意一种集合
-
输出操作:
While(IterationName .hasNext()){
String str = IterationName.next();
System.out.println(str);
}//它的作用只是迭代输出collectionName(即另一种集合)中的内容
特别注意在用Iteration输出内容的时候,一定不要用其他集合的remove方法来删除集合内的元素!
-
Java集合Map
-
保存形式:
Key——value的方式保存
-
常用子类:
HashMap:无序存放,key不允许重复
HashTable:无序存放,key不允许重复
声明格式如下:
Map<Type,Type> MapName = new HashMap/HashTable<Type,Type>();
添加数据:
Map.put(key,values);
文件操作
1.遍历文件夹
步骤:
创建一个遍历文件夹的类;
判断传入对象是否为文件夹;
如果是,则创建一个数组用于接收文件夹的内容;
用循环输出文件夹的内容,在此循环中可以加一个循环用于显示文件夹层级,以方便观察结果;
由于文件夹中还有文件夹存在,所以,首先输出找到的文件名,再判断是否为文件夹,若为文件夹则递归调用函数本身继续遍历。
public class FileDemo01 {
public static void main(String[] args) {
printFile(new File("../handtest"), 1);
}
public static void printFile(File dir, int tab) {
if (dir.isDirectory()) { // 判断此对象是否为文件夹
File next[] = dir.listFiles(); // 使用数组接收内容
for (int i = 0; i < next.length; i++){//利用循环输出文件夹的内容
for (int j = 0; j < tab; j++) { //此循环用于显示文件夹的层级
System.out.print("|--");
}
System.out.println(next[i].getName());
if (next[i].isDirectory()) { // 遇到文件夹,则递归调用函数本身
printFile(next[i], tab + 1);
}
}
}
}
}
2.文件的简单读写操作
-
文件的读操作
步骤:
声明文件对象(此文件要存在,不然之后的操作无法进行);
创建FileInputStream 文件字节输入流;
创建InputStreamReader 字符输入流;
创建BufferedReader 读取缓冲区;
声明字符串对象,将文件中的东西通过此字符串读取出来;
关闭三个流区,顺序为创建时的逆序;
注意在创建三个流区的时候会有异常,应将他们用Try捕获,line = br.readLine()也会有异常,应将其捕获。
public static void main(String[] args) {
File file = new File("test.txt");
if (file.exists()) {
try {
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
BufferedReader br = new BufferedReader(isr);
String line;
while ((line = br.readLine())!=null) {
System.out.println(line);
}
br.close();
isr.close();
fis.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
-
文件的写操作
步骤:
声明文件对象(此文件可以不存在,因为在创建文件输出流的时候可以自动创建文件);
创建FileOutputStream 文件字节输出流;
创建OutputStreamWriter 字符输出流;
创建BufferedWriter 写缓冲区;
调用bw对象的write方法写入数据直至完成;
关闭三个流区,顺序为创建时的逆序;
注意在创建三个流区的时候会有异常,应将他们用Try捕获,调用bw.write()时也会有异常,应将其捕获。
try {
File newfile = new File("newfile.txt");
FileOutputStream fos = new FileOutputStream(newfile);
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
bw.write("fagage\n");
bw.write("fagage\n");
bw.write("fagage\n");
bw.write("fagage\n");
bw.write("fagage\n");
bw.close();
osw.close();
fos.close();
System.out.println("写入完成");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
Java中的IO操作
-
Java IO简介
字节流:在Java中对应的类都以”Stream”结尾。
字符流:在Java中对应的类都以”Reader”或”Writer”结尾。
2.字符、字节与编码
3.使用字节流读写数据:
使用字节流读数据核心代码:
FileInputStream fis = new FileInputStream(文件名);
Byte ByteName[] = new byte[ 大小];
Fis.read(ByteName);
String StringName = new String(ByteName);
System.out.put.println(StringName );
4.使用字节流写数据核心代码:
FileOutputStream fos = new FileOutputStream(文件名);
String StringName = “要写入文件的字符串”;
Byte ByteName[] = StringName.getBytes(“UTF-8”);
Fos.write(ByteName);
编写程序时会提示异常,将其捕获即可。
5.使用字符流读写数据:
将一个文件中的数据copy到另一个文件中的核心代码:
FileInputStream fis = new FileInputStream("java.txt");
FileOutputStream fos = new FileOutputStream("java_new.txt");
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
char input[] = new char[100];
int l = 0;
while ((l = isr.read(input)) != -1) {
//String inputString = new String(input,0,l);
osw.write(input,0,l);
}
isr.close();
fis.close();
osw.close();
fos.close();
需要注意的是:isr.read(数组名)返回的为int类型。而且无论是用字符流还是字节流操作文本数据,中间都得通过字符数组以及字符串进行过度,因为他们的read方法都读入的是字符数组,而输出操作则需要将字符转换成字符串输出。
6.使用带缓冲的字符流读写数据:
FileInputStream fis = new FileInputStream("java.txt");
FileOutputStream fos = new FileOutputStream("java_new_buff.txt");
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedReader br = new BufferedReader(isr);
//BufferedWriter bw = new BufferedWriter(osw);
PrintWriter pw = new PrintWriter(osw,true);
String input;
while ((input = br.readLine()) != null) {
//bw.write(input);
pw.println(input);
}
br.close();
//bw.flush();bw.close();
pw.close();
isr.close();
fis.close();
osw.close();
fos.close();
System.out.println("done");
7.Apache工具包的引用
先创建工程目录。然后在工程目录中创建lib文件夹,将Apache工具包移入该文件夹,然后在eclipse界面建立路径,该工程就可以引用Apache包中的各种API了。详细功能可参见工具包中doc文件夹下的index.html。
Java多线程编程
-
线程与进程
线程:程序中单独顺序的控制流
线程本身是依靠程序进行运行的
线程是程序中的顺序控制流,只能使用分配给程序的资源和环境
进程:执行中的程序
一个进程可以包含一个或多个线程
一个进程至少要包含一个线程
单线程:
程序中指存在一个线程,实际上主方法就是一个主线程
多线程:
多线程是在一个程序中运行多个任务
多线程的目的是更好的使用CPU资源
2.线程的实现
线程的两种实现方法:
继承Thread类
实现Runnable接口
Thread类:
Thread类是在java.lang包中定义的,继承Thread类必须重写run方法
定义格式:
Public Class calssName extends Thread{
Public void run(){ //线程的操作写在里面
};
}
特别注意,在线程启动的时候一定是使用threadName.start()启动线程,而不是run方法。通过线程的run方法启动线程与通过对象调用方法一样,无法实现线程的并发。
Runnable接口
定义格式:
Public class RunnableName implements Runnable{
Public RunnableName(){};
Public void run(){ //线程的操作写在里面
};
}
通过Runnable实现Runnable接口,之后依然要通过Thread来实现线程执行。
Thread ThreadName = new Thread(RunnableName);
ThreadName.start();
3.线程的状态
创建状态:准备好了一个多线程对象
就绪状态:调用了start()方法,等待CPU进行调度
运行状态:执行run()方法
阻塞状态:暂时停止执行,可能将资源交给其他线程使用
终止状态(死亡状态):线程销毁
4.线程的常用方法
取得线程名称getName()
取得当前线程对象currentThread()
判断线程是否启动isAlive()
线程的强行运行join()
线程的休眠sleep() //以ms为单位
线程的礼让yield()
-
线程的优先级
MIN_PRIORITY
MAX_PRIORITY
NORM_PRIORITY
设置格式:
ThreadName.setPriorite(Thread.MIN_PRIORITY);
-
线程同步
同步代码块
在代码块上加上”synchronized”关键字,则此代码块就成为同步代码块
同步代码块格式:
Synchronized(同步对象){
需要同步的代码块;
}
同步方法
除了代码块可以同步,方法也可以同步
方法同步格式:
Synchronized void 方法名称(){}
同步的实质是实现资源共享,以保证多个线程在对同一数据操作时出现违背常理的可能。
7.线程的生命周期
Java中的XML操作
1.XML数据简介
简介:XML即可扩展标记语言,标准通用标记语言的子集,一种用于标记电子文件使其具有结构性的标记语言。它可以用来标记数据、定义数据类型,是一种允许用户对自己的标记语言进行定义的源语言。它非常适合万维网传输,提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。
· XML是一种标记语言,很类似HTML
· XML的设计宗旨是传输数据,而非显示数据
· XML标签没有被预定义,你需要自行定义标签
· XML被涉资未具有自我描述性
· XML是W3C的推荐标准
2.XML与HTML的对比:
3.XML的特点:
4.XML的语法规则:
XML的语法规则很简单,且很有逻辑。这些规则很容易学习,也很容易使用。在XML中,省略关闭标签是非法的,所有元素必须有关闭标签
·XML标签对大小写敏感
·XML必须正确嵌套
·XML文档必须有根元素
·XML的属性值必须加引号
·XML中,空格会被保留
5.使用Java读取XML数据
DOM方式读取XML数据:
步骤:
声明DocumentBuilderFactory 以及DocumentBuilder 用来创建文档;
Builder(由DocumentBuilder 声明的对象确定).parse用来接收外界XML文档;
使用document.getDocumentElement()读取XML根元素;
使用 根元素名.getElementsByTagName()读取XML的标签元素;
使用For循环以及 标签元素名.getAttribute()输出元素属性;
使用 标签元素名.getChildNodes()读取每个标签元素的子节点;
使用循环将子节点的内容输出,由于getChildNodes()得到的返回值为NodeList类型,因此创建NodeList对象接收,但输出的时候会将空格和换行符作为结点输出,因此需要用If判断语句去掉不需要的结点,具体见下面代码。在使用各个方法读取数据的时候,应根据其返回值确定用什么对象接收。
//DOM
DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
//声明之后,就可以创建接收外界的XML文档了
Document document = builder.parse(new File("languages.xml"));
//此处的Document应该使用-org.w3c.dom包中的Document类
Element root = document.getDocumentElement();//读取.XML中的根元素
System.out.println("cat="+root.getAttribute("cat"));
NodeList list = root.getElementsByTagName("lan");
//读取.XML的标签元素,由于返回值为NodeList,所以声明NodeList来接收返回值
for (int i = 0; i < list.getLength(); i++) {
Element lan = (Element) list.item(i);
System.out.println("---------------");
System.out.println("id="+lan.getAttribute("id"));
//获取元素的属性并输出
NodeList clist = lan.getChildNodes(); //获取元素的子节点
for (int j = 0; j < clist.getLength(); j++) {
Node c = clist.item(j);
if (c instanceof Element) {
//由于在使用当前的API解析XML的时候,也将空格作为结点进行解析了,
//所以用此判断语句过滤不需要的结点
System.out.println(c.getNodeName()+"="+c.getTextContent());
6.使用Java创建和传递XML文件:
//DOM
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.newDocument();
Element root = document.createElement("Languages");
root.setAttribute("cat", "it");
Element lan1 = document.createElement("lan");
lan1.setAttribute("id", "1");
Element name1 = document.createElement("name");
name1.setTextContent("Java");
Element ide1 = document.createElement("ide");
ide1.setTextContent("Eclipse");
lan1.appendChild(name1);
lan1.appendChild(ide1); //将标签元素里的元素插入元素标签
Element lan2 = document.createElement("lan");
lan2.setAttribute("id", "2");
Element name2 = document.createElement("name");
name2.setTextContent("Swift");
Element ide2 = document.createElement("ide");
ide2.setTextContent("XCode");
lan2.appendChild(name2);
lan2.appendChild(ide2);
Element lan3 = document.createElement("lan");
lan3.setAttribute("id", "3");
Element name3 = document.createElement("name");
name3.setTextContent("C#");
Element ide3 = document.createElement("ide");
ide3.setTextContent("Visual Studio");
lan3.appendChild(name3);
lan3.appendChild(ide3);
root.appendChild(lan1);
root.appendChild(lan2);
root.appendChild(lan3); //将标签元素插入根节点
document.appendChild(root); //将根节点插入文档
//-------------
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.setOutputProperty("encoding", "UTF-8");
//传递XML文件必须进行的操作,和创建XML的操作一样必不可少
StringWriter writer = new StringWriter();
transformer.transform(new DOMSource(document), new StreamResult(writer));
System.out.println(writer.toString());
//将定义好的XML文件以字符串的形式输出
transformer.transform(new DOMSource(document), new StreamResult(new File("newxml.xml")));
//将写好的XML以文件的形式输出
7.dom4j工具包的引用
先创建工程目录。然后在工程目录中创建lib文件夹,将dom4j工具包中的.jar文件移入该文件夹,然后在eclipse界面建立路径,该工程就可以引用Apache包中的各种API了。详细功能可参见工具包中doc文件夹下的index.html。
Java中的JSON操作
1.JSON简介
JOSON:JavaScript对象表示法(JavaScript Object Notation)
JOSN是存储交换文本信息的语法。
· JSON是轻量级的文本数据交换格式
· JSON独立于语言和平台
· JSON具有自我描述性,更易理解
2.JSON与XML:
3.JSON语法:
JSON语法是JavaScript对象表示语法的子集。
· 数据在键值对中
· 数据由逗号分隔
· 花括号保存对象
· 方括号保存数组
JSON值可以是:
· 数字(整数或浮点数)
· 字符串(在双引号中)
· 逻辑值
· 数组(在方括号中)
· 对象(在花括号中)
· null
Java中的Scoket通信
1.Scoket链接的建立过程
-
服务监听
-
客户端发出请求
-
建立链接
-
通信
Scoket特点:
-
Scoket基于TCP链接,数据传输有保障
-
Scoket适用于建立长时间链接
-
Scoket编程通常应用于即使通讯