一：继承：
特点：
1.super关键字
2.this关键字
3.实例化某对象时，会自动调用无参构造函数
4.子类对象转换为父类对象，可进行隐式转换或显示转换，父类对象转换为子类对象时，只能进行显式转换。
class CA{
String s = "class CA";
}
class CB extends CA{
String s = "class CB";
}
class Convert{
public static void main(String args[]){
CB bb,b = new CB();
CA a,aa;
a = (CA)b;//显式转换
aa = b;//隐式转换
System.out.println(a.s);
bb = (CB)b;//显式转换
}
}
二：多态
特点：
-
foreach循环
for (type variableName : array | collection)//array 数组 collection 容器/集合 { // variableName 自动迭代访问每个元素... } -
public static void main(String[] args){ String[ ] books = {"Hello","World","!"}; //使用foreach 循环来遍历数组元素 //其中 book 将会自动迭代每个数组元素 for(String book : books){ System.out.println(book); } } -
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aBy2H0uq-1678670331795)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1656461154383.png)]
4.抽象类与抽象方法：
如果一个类包含了抽象方法，则必须被定义为抽象类，但抽象类不一定要包含抽象方法。
抽象类中的抽象方法没有方法体，必须在子类中具体实现该方法
三:泛型(集合)
1.iterator的使用
Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。
循环集合元素（while循环和for循环）
package item1;
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorTest {
public static void main(String[] args) {
ArrayList<String> sites = new ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
Iterator<String> it = sites.iterator();
while (it.hasNext()){
String tmp = it.next();
System.out.println(tmp);
}
// for(Iterator it = sites.iterator();it.hasNext();){
// Object tmp = it.next();
// System.out.println(tmp);
// }
}
}
四.输入输出处理
流的划分：
一般的，数据流分为输入流（InputStream）和输出流(OutputStream)，输入流只能读不能写，输出流只能写不能读。有字节流和字符流的划分
一.字节流
1.输入字节流有以下类
InputStream
FileInputStream
FilterInputStream
BufferedInputStream
2.输出字节流有以下类
OutputStream
FileOutputStream
FilterOutputStream
BufferedOutputStream
二.字符流
1.字符输入流：
Reader
BufferedReader
InputStreamReader
FileReader
2.字符输出流：
Writer
BufferedWriter
OutputStreamWriter
PrintWriter
FileWriter
三.主要学习点：
1.标准输入System.in.read()
package item4;
import java.io.IOException;
public class StdInput {
public static void main(String[] args) throws IOException {
System.out.println("input:");
byte b[] = new byte[512];
int count = System.in.read(b);
System.out.println("Output");
for (int i = 0; i < count; i++) {
System.out.print(b[i]+" ");
}
System.out.println();
for (int i = 0; i < count; i++) {
System.out.print((byte)b[i]+" ");
}
System.out.println("count="+count);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MN5OW1ug-1678670331800)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1656582169630.png)]
2.标准输出System.out.print
3.实例（文本替换）
package item4;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class ReplaceText {
public static void main(String[] args) throws FileNotFoundException {
File f;
String filename;
System.out.println("输入文件名：");
Scanner console = new Scanner(System.in);
filename = console.nextLine();
f = new File(new File("src/item4"),filename);
System.out.println("输入要替换的字符串：");
String pattern = console.nextLine();
System.out.println("输入要替换的结果：");
String result = console.nextLine();
PrintWriter pw = new PrintWriter("replace.txt");
Scanner reader = new Scanner(f);
while (reader.hasNextLine()){
String s1 = reader.nextLine();//分行读取文件
String s2 = s1.replaceAll(pattern,result);//进行替换
pw.println(s2);//打印输出
}
console.close();
pw.close();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0gsLUOzb-1678670331803)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1656583793263.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KE6FKfEo-1678670331807)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1656583817066.png)]
五.java多线程
线程的创建：
1.通过继承Thread父类创建线程
1.1引例：使用两个线程分别执行数的求和与平方和的运算
package item5;
//1~1000的平方和运算
public class SumThread extends Thread{
public void run(){
int sum = 0;
for (int i = 1; i <=1000 ; i++) {
sum += i *i;
}
System.out.println("平方和："+sum);
}
}
package item5;
//1~1000和的运算
public class SquareSumThread extends Thread{
@Override
public void run() {
int sum = 0;
for (int i = 1; i <= 1000 ; i++) {
sum += i;
}
System.out.println("和："+sum);
}
}
测试：
package item5;
public class SimpleThreadTest {
public static void main(String[] args) {
Thread sum = new SumThread();
Thread squareSum = new SquareSumThread();
sum.start();
squareSum.start();
}
}
总结：
通过继承父类Thread，创建自定义线程
线程的核心代码在run()方法中，也被称为线程体
创建线程对象后，run()方法不会自动执行，需要调用start（）方法启动线程
线程的执行是并发的，独立线程之间没有确定的顺序关系，输出结果的先后顺序因此不确定。
2.通过实现接口创建线程
package item5;
//自己创建的线程是并发执行的
public class MyThread implements Runnable{
int count = 1, number;
public MyThread(int i) {
number = i;
System.out.println("创建线程："+number);
}
@Override
public void run() {//线程体
while (true){
System.out.println("线程："+number+":计数"+count);
if (++count == 6){
return;
}
}
}
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
new Thread(new MyThread(i+1)).start();//线程对象
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCfkmMut-1678670331812)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1656587715607.png)]
六.网络通信
多客户端Socket通信（将socket对象放置到线程中）
ServerThread线程类
package item6;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
public class ServerThread extends Thread{
private Socket s;
private DataInputStream is;
private DataOutputStream os;
ServerThread(Socket socket) throws IOException {
super();
s = socket;
is = new DataInputStream(s.getInputStream());
os = new DataOutputStream(s.getOutputStream());
start();
}
@Override
public void run() {
try{
String str;
double result;
double zhi;
boolean NotEnd = true;
while (NotEnd){
str = is.readUTF();
if (!str.equals("bye")){
zhi =Double.parseDouble(str);
System.out.println("接受到的值为："+zhi);
result = zhi * zhi;
str = Double.toString(result);
os.writeUTF(str);
os.flush();
System.out.println("平方值"+str+"已经发送");
}else {
NotEnd = false;
os.writeUTF("bye");
os.flush();
}
}
is.close();
os.close();
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
服务器主程序：
package item6;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class MultiServer {
public static void main(String[] args) {
try {
System.out.println("等待连接");
ServerSocket serverSocket = new ServerSocket(5500);
Socket s = null;
while (true){
s = serverSocket.accept();
new ServerThread(s);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
客户端程序：
package item6;
import java.io.*;
import java.net.Socket;
public class Client {
public static void main(String[] args) {
try{
Socket s = new Socket("localhost",5500);
DataInputStream is = new DataInputStream(s.getInputStream());
DataOutputStream os = new DataOutputStream(s.getOutputStream());
System.out.println("输入待求平方值，输入bye结束。");
String outStr,inStr;
boolean NotEnd = true;
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
while (NotEnd){
outStr = buf.readLine();
os.writeUTF(outStr);
os.flush();
inStr = is.readUTF();
if (!inStr.equals("bye")){
System.out.println("返回结果："+inStr);
}else {
NotEnd = false;
}
}
is.close();
os.close();
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
结果：
客户端经过服务器通过输出流的写方法os.writeUTF()发送数据给socket
线程中的方法体run方法中有相应的is.readUTF() 方法读取数据，再通过os.writeUTF(str)方法，将结果通过服务器返回给客户端。
客户端在通过is.readUTF()方法读取数据并显示。
System.out.println("返回结果："+inStr);
}else {
NotEnd = false;
}
}
is.close();
os.close();
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
结果：
客户端经过服务器通过输出流的写方法os.writeUTF()发送数据给socket
线程中的方法体run方法中有相应的is.readUTF() 方法读取数据，再通过os.writeUTF(str)方法，将结果通过服务器返回给客户端。
客户端在通过is.readUTF()方法读取数据并显示。
994
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
