JavaSE回顾
JavaSE
范围限定类（public,private,protected,default)
- public
- .java文件只有一个public class且与java文件名相同
- protected
- 同包或者子类可见
- private
- 类内可见
- default
- 同包可见
JavaDoc
参数信息
- @author 作者名
- @version 版本名
- @since 指明需要使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
生成doc文件
cmd命令生成（不推荐）
#当前目录的cmd下命令
javadoc -encoding UTF-8 -charset UTF-8 Date.java#会生成很多文件，点击index.html即可
点击Date类
IDEA生成
Scanner
package com.ddlWarrior.learn01;
import java.util.Scanner;
public class TestScanner {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
if(scanner.hasNext()){
// String str = scanner.nextLine();
String str = scanner.next();//忽略前导空格，以空格结束
System.out.println(str);
}
//属于io流不关闭就会一直占用资源，不用就要关闭
scanner.close();
}
}
忽略前导空格，以空格结束
接收空格，以enter键结束输入
内存分析
稀疏数组
-
用时间换空间
-
记录原数组的row，col，和不同元素的数量sum
-
创建稀疏数组
int[] sparseArray = new int[sum+1][3]; //sparseArray 第一行存放，row，col，sum //之后每一行存放不同元素的行号，列好，值
方法
方法的定义
- 修饰符
- 返回类型
- 方法名（注意规范）
- 参数列表
- 异常抛出
public void readFile(String file) throws IOException{
}
方法的调用
-
静态方法
- 可以直接通过类名.方法调用，不用创建实例
- 静态方法只能调用静态方法和静态变量，或者实例化对象，再调用该对象的非静态方法和非静态变量
- 和类一起加载
-
非静态方法
- 需要创建实例，再调用
- 类实例化后才存在
-
形参和实参
-
值传递和引用传递
-
this关键字
类
构造器
- new 一个对象本质就是调用构造器
- 定义了有参构造就必须显示定义无参构造
封装
- 高内聚：类的内部操作细节自己完成，不允许外部干涉
- 低耦合：仅暴露少数少数方法给外界调用
- 属性私有
继承
-
私有的东西无法被继承
-
类和类间关系还有依赖、组合、聚合等
-
super
- 调用父类的属性用 super
内部类
成员内部类
-
通过先实例化外部类，再实例化内部类
-
//以下外部类和内部类为例 package com.ddlWarrior.learnOOP; public class Outer { private int id; public void out(){ System.out.println("outer"); } public class iner{ public void in(){ System.out.println("iner"); } } } -
package com.ddlWarrior.learnOOP; public class Demo2 { public static void main(String[] args) { Outer outer = new Outer(); //有点绕……………… Outer.iner iner = outer.new iner(); iner.in(); } }
-
-
内部类可以获得外部类的私有属性
-
外部类只能使用public和缺省的包访问权限
-
内部类可为静态，可用protected和private修饰
静态内部类
- 静态类先加载，所以不能访问非静态的外部属性了
局部内部类
-
在方法里面定义类
-
public void method(){ class in{ public void in(){} } }
匿名内部类
- 没有名字初始化类，不用将实例保存在变量中
- 比如接口的实现类
异常
- java将异常当成对象来处理(Throwable是最高级别的，包括Error， Exception)
- 错误Error异常Exception
- Error由JVM抛出，通常是致命的错误，程序无法控制和处理，一般此时JVM会选择终止线程
- Exception是需要捕获处理的
关键字：try,catch,finally,throw,throws
-
finally可以不用，但是一般用在IO,资源的关闭，善后工作
-
多个catch要按照 异常判断范围从小到大的顺序来写，如果有多个异常，只捕获最开始出现的
-
package com.ddlWarrior.learnOOP; public class Demo2 { public static void main(String[] args) { try{ // System.out.println(1/0);// a(); }catch (Error e){ System.out.println("error"); }catch (Exception e){ System.out.println("exception"); }catch (Throwable t){ System.out.println("throwable"); }finally { System.out.println("finally"); } } public static void a(){ b(); } private static void b() { a(); } }
-
-
主动抛出异常throw在方法中使用，throws在方法声明处使用
-
package com.ddlWarrior.learnOOP; public class Demo2 { public static void main(String[] args) { int a =1; int b =0; try { test(a,b); } catch (Exception e) { // e.printStackTrace(); System.out.println("exception"); } } // 假设该方法无法处理异常，，在方法上抛出异常 public static void test(int a,int b) throws ArithmeticException{ if(b==0){ throw new ArithmeticException();//throw主动抛出异常,一般在方法中使用 } } }
-
自定义异常
- 创建自定义异常类
- 在方法中通过throw抛出异常对象
-
- 如果在抛出异常的方法中处理异常，使用try-catch捕获处理
- 否则在方法的声明处通过throws关键字指明要抛出给调用者的异常，然后在调用者中捕获处理
定义异常类
package com.ddlWarrior.learnThrowable;
//自定义的异常类
public class CustomException extends Exception{
private int detail;
public CustomException(int detail) {
this.detail = detail;
}
//toString:异常的打印信息
@Override
public String toString() {
return "CustomException{" + detail + '}';
}
}
处理异常
package com.ddlWarrior.learnThrowable;
public class Test {
//可能存在异常的方法
public static void test(int a) throws CustomException{
if(a>10){
throw new CustomException(a);//抛出
}
}
public static void main(String[] args) {
try {
test(11);
} catch (CustomException e) {
// e.printStackTrace();
System.out.println("CustomException = " + e);
}
}
}
实际应用注意
- 多重catch块后加一个
catch(Exception e){}捕获可能遗漏的异常 - 不确定的代码加上try-catch处理
- 尽量在catch块中真正地处理，而不是仅仅打印
- 尽量添加finally释放占用的资源如：IO, Scanner
流、文件
| 字节流 | 字符流（要考虑编码问题） | |
|---|---|---|
| 输入 | InputStream | Reader |
| 输出 | OutputStream | Writer |
- 字节流
- read() 逐字节地以二进制的原始方式读取数据
- write()
- 字符流（差别在读到的是字符不是字节）
- read()
节点流和处理流
节点流
- 可以从或向一个特定的地方（节点）读写数据
- 如文件流 FileInputStream ，内存流 ByteArrayInputStream
处理流
- 对已存在的流的连接和封装，处理流又称过滤流（Filter）
- 如缓冲处理流 BufferedReader
流的链接：一个流对象经过其他流的多次包装
BufferedReader in = new BufferedReader(new InputReamReader(new FileInputStream(file), "utf-8"));
| 节点类型 | 字节流 | 字符流 |
|---|---|---|
| File 文件 |
FileInputStream FileOutputStream |
FileReader FileWriter |
| Memory Array 内存数组 |
ByteArrayInputStream ByteArrayOutputStream |
CharArrayReader CharAarryWriter |
| Memory String 字符串 |
StirngReader StringWriter |
|
| Pipe 管道 |
PipedInputStream PipedOutputStream |
PipedReader PipedWriter |
| 处理类型 | 字节流 | 字符流 |
|---|---|---|
| Buffering 缓冲 |
BufferedInputStream BufferedOutputStream |
|
| Converting between bytes and character 字节流转为字符流 |
InputStreamReader OutputStreamReader |
|
| Data convertion 基本数据类型转化 |
DataInputStream DataOutputStream |
|
| Printing 可显示处理 |
PrintWriter |
常见的内容
二进制
文本
-
package com.ddlWarrior.learnIO; import java.io.*; import java.nio.charset.Charset; public class TestRead2 { public static void main(String[] args) { String filePath = "C:\\Users\\19000\\Desktop\\IDEA项目\\JavaSE\\src\\com\\ddlWarrior\\learnIO\\a.txt"; BufferedReader bufferedReader = null; try { bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), Charset.forName("UTF-8"))); } catch (FileNotFoundException e) { e.printStackTrace(); } String line = null; while (true){ try { if (!((line = bufferedReader.readLine())!=null)) break; } catch (IOException e) { e.printStackTrace(); } System.out.println(line); } } } -
package com.ddlWarrior.learnIO; import java.io.IOException; import java.nio.charset.Charset; import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; public class TestRead { public static void main(String[] args) { String filePath = "C:\\Users\\19000\\Desktop\\IDEA项目\\JavaSE\\src\\com\\ddlWarrior\\learnIO\\a.txt"; List<String> lines = null; try { lines = Files.readAllLines(Paths.get(filePath), Charset.forName("UTF-8")); } catch (IOException e) { e.printStackTrace(); } for (String s : lines) { System.out.println(s); } } }
对象
- 序列化（serialize）：将对象或基本数据写入文件的过程
- 反序列化（deserialize）：从文件中读取出来的过程
- 要求对象实现Serializable接口，才能读写（反序列化，序列化）
- 该接口没有方法，只是一个标记
IO流的关闭
-
先打开的后关闭，后打开的先关闭
-
Closes this stream and releases any system resources associated with it. If the stream is already closed then invoking this method has no effect.(关闭此流并释放与之关联的所有系统资源。如果流已关闭，则调用此方法无效。)
-
也就是说可以只关闭处理流
-
package com.ddlWarrior.learnIO; import java.io.*; import java.nio.charset.Charset; public class TestRead2 { public static void main(String[] args) { String filePath = "C:\\Users\\19000\\Desktop\\IDEA项目\\JavaSE\\src\\com\\ddlWarrior\\learnIO\\a.txt"; BufferedReader bufferedReader = null; try { bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), Charset.forName("UTF-8"))); String line = null; while (true){ try { if (!((line = bufferedReader.readLine())!=null)) break; } catch (IOException e) { e.printStackTrace(); } System.out.println(line); } } catch (FileNotFoundException e) { e.printStackTrace(); }finally { try { bufferedReader.close(); } catch (IOException e) { e.printStackTrace(); } } } }
文件
递归遍历桌面所有文件夹和文件
package com.ddlWarrior.learnIO;
import java.io.File;
public class TestDirectory {
static int count = 0;
public static void main(String[] args) {
ListFiles(new File("C:\\Users\\19000\\Desktop"));
System.out.println(count);
}
private static void ListFiles(File file) {
if (!file.exists() || !file.isDirectory()){
return;
}
String[] list = file.list();
for (String s :
list) {
File file1 = new File(file,s);
count++;
if (file1.isFile()){
System.out.println(file+"\\"+file1.getName()+"\t"+file1.length());
}else{
System.out.println(file+"\t"+"<dir>");
ListFiles(file1);
}
}
}
}
正则表达式
写法
- 字符{数量}位置
- 如[0-9]{2,4}\b
- 表示0到9
- 出现数量2至4次
- \b表示边界
网络、多媒体和数据库编程
网络编程
需要导入httpclient包
网络信息和图片获取
-
package com.ddlWarrior.learnInternet; import org.apache.hc.client5.http.fluent.Request; import javax.imageio.ImageIO; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import java.net.URL; public class TestInternet01 { public static void main(String[] args) { String stock = "sz000837"; String str = null; String charType = "min"; String imageURL = "http://image.sinajs.cn//newchart/"+charType+"/n/"+stock+".gif"; try { str = Request.get("http://hq.sinajs.cn/list="+stock).execute().returnContent().asString(); System.out.println(str); } catch (IOException e) { e.printStackTrace(); } try { BufferedImage read = ImageIO.read(new URL(imageURL)); ImageIO.write(read,"gif", new File("a.gif")); } catch (IOException e) { e.printStackTrace(); } } }
应用实例：获取建议词
实现底层网络通信
- Socket类：客户端建立Socket对象
- ServerSocket类：服务端
多媒体编程
数据库编程
面向对象
本质：以类的方式组织代码，以对象的方式组织（封装）数据
浙公网安备 33010602011771号