快速复习Java
Java快速复习 -1 -基础,面向对象,异常,集合,io流,多线程,网络编程,XML,注解
变量 数据类型 运算符
package Day_01;
/** 快速java复习
* 把自己一些以前学习中不太清楚,不太明白,容易忘记,或已经忘记的知识,快速复习一遍.
*
* + 运算符,操作符 operator
* 5+6 表达式 expression
* 5 6 操作数 operand
* int m= 5+6; 语句 sentence
*/
public class HelloWorld {
public static void main(String[] args) {
//基础篇
//数据类型
//1.整数型
byte a = 127; // 范围 -128~127
short b = 29999; // 范围 正负三万
int c = 999999999; // 范围 正负21亿
//赋值long类型时,数值如果比int类型表述范围大时,必须要在数值后面加l/L.
long d = 999 ;
long e = 9999999999L; // 范围 很大很大
//2.浮点型
float f = 3.14f; //如果用float表示小数,必须在后面加f
double g = 3.14;
//3.字符型
char h = 'a'; //单引号引起来的单个字符
//4.布尔类型
boolean flag = true;//布尔类型只有两个true,false
//运算符
//+的拼接字符串功能
System.out.println(5+6+"abc");//11abc
System.out.println("abc"+5+6);//abc56
//只要+左右两侧任意一侧是字符串,结果一定是字符串
//++
int k = 5;
int x = k++ +1;//++在后面,先运算,后加1
System.out.println(k);//6
System.out.println(x);//6
k = 5;
int y = ++k +1;//++在前面,先加1,再运算
System.out.println(k);//6
System.out.println(y);//7
//关系运算符 -- 最终结果是boolean值 要么true 要么false
//逻辑运算符
//&&逻辑与: 两个数都是true才是true,只要有一个false,就是false.
//||逻辑或: 两个数都是false才是false,只要有一个true,就是true.
}
}
方法重载
方法的重载: 在同一个类中,方法名相同,形参列表不同的多个方法,构成方法的重载. (方法的重载之和方法名,形参列表有关,与其它无关)
数值
增强for循环 和 普通for循环的区别在于: 普通for循环可以涉及到关于索引的操作, 增强for循环不可以,但是代码简单.
package SpeedRun;
public class S_02 {
public static void main(String[] args) {
//声明数组
int [] arr = new int[4];
//给元素赋值
arr[0] = 3;
arr[1] = 6;
arr[2] = 9;
arr[3] = 10;
//调用元素
System.out.println(arr[2]); //9
//遍历数组 for循环
for (int i = 0 ; i <= 3; i++){
System.out.println("第"+(i+1)+"个元素是:"+arr[i]);
}
//增强for循环
for (int num:arr){
System.out.println(num);
}
//增强for循环 和 普通for循环的区别在于: 普通for循环可以涉及到关于索引的操作, 增强for循环不可以,但是代码简单.
}
}
面向对象_类和对象
对于一个类来说, 一般有三种成员: 属性, 方法, 构造器. 这三种成员都可以定义0个或多个.
构造方法也叫构造器
其作用是: 一个创建对象时被自动调用的特殊方法,用于对象的初始化,比如给属性赋值.
构造方法的声明格式: 修饰符 (注意没有返回值类型) 类名 (形参列表) { n条 语句 }
若无形参列表, 称之 无参构造器(空构造器)
若有形参列表, 称之 有参构造器.
尽量保证空构造器存在, 以后学到框架,某些框架底层需要空构造器, 没有会报错.
构造器快速添加快捷键: alt + insert
构造器的四要点
- 构造器的方法名必须和类名一致
- 构造器通过new关键字调用
- 构造器不能定义返回值类型, 不能再构造器里使用return关键字来返回某个值.
- 如果我们没有定义构造器, 则编译器会自动定义一个无参的构造器. 如果以定义则编译器不会自动添加.
- 构造方法也是方法, 只不过有特殊的作用而已, 与普通方法一样, 构成方法重载.
继承 方法的重写
概念: 当子类对父类提供的方法不满意时, 要对父类的方法进行重写.
格式要求: 子,父类方法名必须一致, 参数列表(个数,类型,顺序)也要和父类一致.
重载和重写的区别: (完全不一样,毫无关系)
- 重载: 在同一个类中, 当方法名相同, 形参列表不同时,多个方法构成重载.
- 重写: 在不同类中, 子类对父类提供的方法不满意, 对父类的方法进行重写.
多态
多态跟属性无关, 多态的是方法的多态, 而不是属性的多态.
多态的三要素: 继承, 重写, 父类引用指向子类对象(也就是:表面上是调用父类, 但实际操作的是子类.)
多态的好处: 提高代码的扩展性.
异常
try - catch
try{
//两个数的商
int num1 = 12;
int num2 = 0;
System.out.println("两个数的商是:"+ num1/num2)
}catch (Exception){
System.out.println("程序出错了.")
}finally {
System.out.println("程序无论是否出现异常,这个逻辑都要执行.")
}
System.out.println("上面是案例1")
情况1: try块中没异常, 不执行catch代码块, 执行catch后面的代码.
情况2: try块中出现异常, catch中异常类型匹配(相同或者父类), 执行catch代码块, 和catch块后边的代码.
情况3: try块中出现异常, catch中异常类型不匹配, 不执行catch和其后面的代码,程序中断运行.
finally : 程序无论是否出现异常,这个逻辑都要执行.
异常三连 : try , catch , finally .
throw / throws的区别
- 位置不同
throw: 方法内部
throws: 方法签名处, 方法声明处.
- 内容不同
throw + 异常对象
throws + 异常类型
- 作用不同
throw: 异常出现的源头, 制造异常.
throws: 在方法声明处, 告诉方法调用者, 这个方法可能会出现异常, 调用者自己处理.
public static void main(String[] args) {
}
public static void devide() throws Exception {//throws 抛出异常 异常的类型
int num1 = 12;
int num2 = 3 ;
if (num2==0){
// System.out.println("被除数是0");
//人为制造异常 异常的对象
throw new Exception();//有两种处理方法: 1.自己处理,try-catch. 2.抛出去, 谁调用,谁处理, throws...
}else {
System.out.println("两个数的商是: " + num1 / num2);
}
}
集合
public static void main(String[] args) {
//声明集合
ArrayList arr = new ArrayList();
//增
arr.add(0,"aaa");
arr.add(1,"bbb");
arr.add(2,"ccc");
arr.add(3,"ddd");
//删
arr.remove(3);
//改
arr.set(0,"zzz");
//查
arr.get(1);
//遍历 (for循环)
for (int i = 0; i<arr.size(); i++){
System.out.println(arr.get(i));
}
}
IO流
IO流的引入
File类对象可封装要操作的文件, 可对文件进行如查看文件大小, 判断文件是否隐藏,是否可读等. 但是并不涉及文件内容相关的操作, 此时需要借助 I/O流 完成.
IO流的分类
方式1: 按照方向划分. 输入流, 输出流
方式2: 按照处理单元划分. 字节流, 字符流
方式3:按照功能划分. 节点流(单个流), 处理流(多个流)
IO流的体系结构
package SpeedRun;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
//读取文件, 输入
public class S_05 {
public static void main(String[] args) throws IOException {
//对文件进行操作,必须将文件封装成具体的File类对象
File file = new File("d:\\dog.txt");
//"管子" = 流 = 字符输入流 (将这个管子怼到文件上)
FileReader fr = new FileReader(file);
//开始动作 "吸"
int a = fr.read();
while (a!=-1){
System.out.println(a);
a = fr.read();
}
//流关闭
fr.close();
}
}
package SpeedRun;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
//写入文件, 输出
public class S_06 {
public static void main(String[] args) throws IOException {
//定义字符串
String s = "123abc";
//创建对象,封装文件
File file = new File("d:\\test.txt");
//字符输出流
FileWriter fileWriter = new FileWriter(file);
//动作: 写入文件(输出)
fileWriter.write(s);
//关闭流
fileWriter.close();
}
}
案例: 图书管理系统
多线程
进程: 是操作系统进行资源分配的基本单位.
线程: 是操作系统调度执行的基本单位.
创建线程的三种方法:
- 继承Thread类
- 实现Runnable接口
- 实现Callable接口
package SpeedRun;
//子线程类
//创建一个线程类 Sub_Thread
//想具备多线程能力 extends->Thread
public class Sub_Thread extends Thread{
@Override//子线程任务放在这个方法里
public void run() {
//任务也是输出数字
for (int i = 0; i < 10000; i++) {
System.out.println("子线程:"+i);
}
}
}
//==========================================
package SpeedRun;
//主线程类/主方法
public class ThreadTest {
public static void main(String[] args) {
//main方法作为主方法,里面的任务就是主线程任务
for (int i = 0; i < 10; i++) {
System.out.println("Main_Thread:"+i);
}
//创建子线程对象,执行子线程任务
Sub_Thread st = new Sub_Thread();
//执行任务,不是直接调用run方法,而是用".start方法"将线程启动.
st.start();//一旦子线程启动,就会和主线程争抢资源.
//主线程中加入另一个循环,来演示它与主线程争抢资源
for (int i = 0; i < 10000; i++) {
System.out.println("___Main_Thread:"+i);
}
}
}
网络编程
概述
IP地址: 用来标志网络中的一个通信实体的地址.通信实体可以是计算机,路由器等.
端口号: IP地址用来标志一台计算机, 但是一台计算机上可能有多种应用程序, 使用端口来区分这些应用程序.
通信协议的分层:
- 名义上标准: ISO/OSI参考模型
- 事实上的标准: TCP/IP协议栈(Internet使用的协议)
Socket套接字 单向通信 双向通信
套接字的作用: 是传输层提供给应用层的编程接口. 是应用层与传输层之间的桥梁.
package SpeedRun.SocketTest;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
//服务器端
public class Server {
public static void main(String[] args) throws IOException {
System.out.println("服务器端已启动.");
//套接字 ServerSocket
ServerSocket ss = new ServerSocket(8888);
//等待客户端发送数据
Socket a = ss.accept();
//服务器接收数据 是输入流
InputStream is = a.getInputStream();
//套一个数据流来接收数据
DataInputStream dis = new DataInputStream(is);
//接收客户端的数据
String s = dis.readUTF(dis);
System.out.println("客户端说:"+s);
//向客户端发送信息
OutputStream os = a.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
dos.writeUTF("服务器说:客户端,我收到你的信息啦.");
//关闭流和网络资源 , 顺序为从下往上关闭.
dos.close();
os.close();
dis.close();
is.close();
a.close();
ss.close();
}
}
//==================================================
package SpeedRun.SocketTest;
import java.io.*;
import java.net.Socket;
//客户端
public class Client {
public static void main(String[] args) throws IOException {
System.out.println("客户端已启动.");
//套接字 指定IP和端口号 (win+r Terminal窗口中,输入 IPconfig查看IP地址,右键复制.)
Socket s = new Socket("192.168.31.171",8888);
//获取套接字s的输出流
OutputStream os = s.getOutputStream();
//输出流外面再套一个数据流来发送数据
DataOutputStream dos = new DataOutputStream(os);
//调用writeUTF方法来传输字符串数据
dos.writeUTF("你好,服务器,我是客户端.");
//接收服务器发送来的信息
InputStream is = s.getInputStream();
DataInputStream dis = new DataInputStream(is);
String s1 = dis.readUTF();
System.out.println(s1);
//关闭流和网络资源 , 顺序为从下往上关闭.
dos.close();
os.close();
s.close();
}
}
//====================================
服务器端已启动.
客户端说:你好,服务器,我是客户端.
客户端已启动.
服务器说:客户端,我收到你的信息啦.
XML
引入和定义
定义: XML是可扩展标记语言(EXtensible Markup Language)
作用: XML是不作为的，XML不会做任何事情。XML被设计用来结构化、存储以及传输信息。它仅仅是纯文本而已。它仅仅将信息包装在XML标签中。我们需要编写软件或者程序，才能传送、接收和显示出这个文档。
定义XML
1、必须有声明语句。
XML声明是XML文档的第一句，其格式如下：
2、XML文档有且只有一个根元素
良好格式的XML文档必须有一个根元素，就是紧接着声明后面建立的第一个元素，
其他元素都是这个根元素的子元素，根元素完全包括文档中其他所有的元素。
3、注意大小写
在XML文档中，大小写是有区别的。“A”和“a”是不同的标记。
4、所有的标记必须有相应的结束标记
所有标记必须成对出现，有一个开始标记，就必须有一个结束标记，否则将被视为误。
5、属性值使用引号
所有属性值必须加引号（可以是单引号，也可以是双引号，建议使用双引号），否则将 被视为错误。
6、XML中可以加入注释
注释格式：＜！—→＞
<?xml version="1.0" encoding="utf-8"?>
<!--
注释部分:
version 是版本号,
encoding 是文档编码
Students 为根标签
student 为子标签 name age score为student的子标签
id="001" 是student子标签的属性
-->
<Students>
<student id="001">
<name>小明</name>
<age>12</age>
<score>99</score>
</student>
<student id="002">
<name>小轩</name>
<age>13</age>
<score>95</score>
</student>
</Students>
解析XML
dom4j 解析工具的使用
在程序中创建目录, 把jar包复制到目录中, 右键文件 选Add as Library... 图标前多个箭头
//运行结果
该子节点的属性: id---001
节点: name---小明
节点: age---12
节点: score---99
注解
注解是代码里的特殊标记, 使用注解可以在原有逻辑不变的情况下,嵌入一些补充信息.
使用注解时要在其前面增加@符号, 可以把注解当成一个修饰符使用. 用于修饰它支持的元素.(包, 类, 构造器, 方法, 属性, 参数, 局部变量).
在javaSE中,注解使用比较简单,例如标记过时的功能, 忽略警告等. 但在JavaEE/Android中式更重要的角色. 一定程度上 框架 = 注解 + 反射 + 设计模式
package SpeedRun;
/*
简单的几个注解:
@author 作者
@version 版本
@param 参数
@return 返回值
@Override 方法重写
*/
public class S_07 extends S_07_01{
public static void main(String[] args) {
}
@Override
public void speak() {
System.out.println("这是对父类方法的重写.");
}
/**
*
* @param a 第一个数
* @param b 第二个数
* @return 俩数的和
*/
public static int add(int a,int b){
return a+b;
}
}
浙公网安备 33010602011771号