Day 23：JAVA SE复习

作业

1.多线程下载图片

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;

public class imageclient_Demo1 {
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        Socket socket = new Socket(InetAddress.getLocalHost().getHostAddress(),9090);
        InputStream IN = socket.getInputStream();
        FileOutputStream out = new FileOutputStream("F:\1.jpg");
        byte[] buf = new byte[1024];
        int content = 0;
        while((IN.read(buf))!=-1) {
            out.write(buf,0,content);
        }
        out.close();
        socket.close();
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashSet;

public class imageserver_Demo2 extends Thread{
    Socket socket;
    
    HashSet<String> ips = new HashSet<String>();
    
    public imageserver_Demo2(Socket socket) {
        // TODO Auto-generated constructor stub
        this.socket = socket;
    }
    
    public void run() {
        try {
            // TODO Auto-generated method stub
            OutputStream outputStream = socket.getOutputStream();
            FileInputStream in = new FileInputStream("F:\2.jpg");
            byte[] buf = new byte[1024];
            int content = 0;
            while((in.read(buf))!=1) {
                outputStream.write(buf,0,content);
            }
            String ip = socket.getInetAddress().getHostAddress();
            if(ips.add(ip)) {
                System.out.println("您好！"+ip+"。您已成功下载，当前下载量"+ips.size());
            }
            in.close();
            socket.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
    public static void main(String[] args) throws IOException {
        ServerSocket serversocket = new ServerSocket(9090);
        
        while(true) {
            Socket socket = serversocket.accept();
            new imageserver_Demo2(socket).start();
        }
    }

}

2.实现登陆与注册功能。

　　客户端与服务端连接的时候，就要提示客户端请选择功能。
　　客户端注册的时候，用户名与密码都是发送给服务端的，服务端需要把数据保存到服务端的文件上。
　　登陆：登陆的时候客户端输入用户名与密码发送给服务端，服务端需要校验，返回结果给客户端。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;

public class LoginClinet {
    
    public static void main(String[] args) throws IOException {        
        Socket socket = new Socket(InetAddress.getLocalHost(),9090);
        OutputStreamWriter  socketOut = new OutputStreamWriter(socket.getOutputStream());    
        BufferedReader socketReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        BufferedReader keyReader = new BufferedReader(new InputStreamReader(System.in));
        while(true){
            System.out.println("请选择功能： A(登陆)  B(注册)");
            String option = keyReader.readLine();
            if("a".equalsIgnoreCase(option)){
                getInfo(socketOut, keyReader, option);
                //读取服务器反馈的信息
                String line = socketReader.readLine();
                System.out.println(line);
            }else if("b".equalsIgnoreCase(option)){
                getInfo(socketOut, keyReader, option);
                //读取服务器反馈的信息
                String line = socketReader.readLine();
                System.out.println(line);
            }
        }        
    }

    public static void getInfo(OutputStreamWriter  socketOut,BufferedReader keyReader, String option)throws IOException {
        System.out.println("请输入用户名:");
        String userName = keyReader.readLine();
        System.out.println("请输入密码：");
        String password = keyReader.readLine();
        String info = option +" "+userName+" "+password+"
";
        socketOut.write(info);
        socketOut.flush();
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Properties;

public class LoginServer extends Thread {

    Socket socket;
    static File file = new File("F:\users.properties");
    public LoginServer(Socket socket) {
        this.socket = socket;
    }
    static {
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    @Override
    public void run() {
    while(true){
            try {
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                OutputStreamWriter socketOut = new OutputStreamWriter(
                socket.getOutputStream());
                String info = bufferedReader.readLine();
                String[] datas = info.split(" ");
                String option = datas[0];
                String userName = datas[1];
                String password = datas[2];
                if ("a".equalsIgnoreCase(option)) {
                    Properties properties = new Properties();
                    properties.load(new FileReader(file));
                    if (properties.containsKey(userName)) {
                        String tempPass = properties.getProperty(userName);
                        if (password.equals(tempPass)) {
                            socketOut.write("欢迎" + userName + "登陆成功
");
                        } else {
                            socketOut.write("密码错误
");
                        }
                    } else {
                        socketOut.write("用户名不存在，请重新输入...
");
                    }
                    socketOut.flush();
                } else if ("b".equalsIgnoreCase(option)) {
                    Properties properties = new Properties();
                    properties.load(new FileReader(file));
                    if (!properties.containsKey(userName)) {
                        properties.setProperty(userName, password);
                        properties.store(new FileWriter(file), "users");
                        socketOut.write("注册成功
");
                    } else {
                        socketOut.write("用户名已经被注册，请重新输入
");
                    }
                    socketOut.flush();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9090);
        while (true) {
            Socket socket = serverSocket.accept();
            new LoginServer(socket).start();
        }
    }
}

梳理复习

continue: 跳过本次循环语句，继续下一次循环。

continue的作用范围：只能适用于循环语句。一旦执行了continue语句，那么在循环体内continue之后的循环语句跳过执行。

for(int i = 0 ; i<5 ; i++){
            if(i==1){
                continue;
            }

            System.out.println("i="+i);
        }

break: 用于结束一个循环语句或者是一个switch语句.

break作用范围：只能用于循环语句或者是switch语句。

outer:for(int j = 0 ; j<2; j++){ // j=0  j=1
            inner:for(int i = 0 ; i<3 ; i++){ //i=0
                System.out.println("hello world");
                break outer; //结束当前所在的循环。 如果配合标识的使用，可以作用于外层的for循环。
            }
        }

return：也可以用来终止循环

for(int i = 0 ; i<3 ; i++){
     System.out.println("hello world");
     return;
}

函数重载的要求
　　1. 函数名一致。
　　 2. 形参列表不一致（形参的个数不一致或者是形参对应的类型不一致）
　　3. 与返回值类型无关。
函数重写的要求
　　1. 子父类的函数名与形参列表必须一致。
　　2. 子类的权限修饰符必须要大于或者等于父类的权限修饰符。
　　 3. 子类的返回值类型必须要小于或者等于父类的返回类型。
　　4. 子类抛出的异常类型必须要小于或者等于父类抛出的异常类型。

匿名对象：没有引用类型变量指向的对象就称作为匿名对象。

匿名对象的主要作用：简化书写。

匿名对象主要用于两种应用场景：
　　1. 如果一个对象的方法只会调用一次的时候，然后该对象就不再使用了，这时候就就可以使用匿名对象。
　　 2. 作为参数传递。

// Runtime runtime = Runtime.getRuntime();
Runtime.getRuntime().exec("C:\Windows\notepad.exe");

FileReader fileReader = new FileReader("F:\a.txt");
BufferedReader bufferedReader = new BufferedReader(new FileReader("F:\a.txt"));

封装的步骤：
　　1. 私有化要封装的属性。
　　2. 根据需求提供对应的get或者是set方法。

封装的好处：
　　  1.提高数据的安全性。
  　　2.操作简单。
  　　3.隐藏实现。

封装一定会用的场景：如果是实体类的成员属性，我们在现实开发中全部都封装起来。

class Member{
    private String name;
    private String sex;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setSex(String sex){
        if("男".equals(sex)||"女".equals(sex)){
            this.sex = sex;
        }
    }
    public String getSex(){
        return sex;
    }    
}
public class Demo8 {
    public static void main(String[] args) {
        Member m = new Member();
        m.setName("狗娃");
        m.setSex("男");
    }
}

构造代码块：给对象进行统一的初始化工作。
应用场景：如果创建任意对象的时候都需要调用某个方法为该对象进行初始化时，这时候就可以使用构造代码块。
静态代码块:静态代码块是静态代码块所属的类被加载到内存的时候执行的。
静态代码块的应用场景：以后主要用于准备一个项目的初始化工作。
比如：从配置配置文件中读取数据库用户名与密码。

class Baby{
    int id;
    String name;
    {
        cry();
    }
    static{
        System.out.println("静态代码块执行了...");
    }
    public Baby(int id, String name) {
        this.id = id;
        this.name = name;    
    }
    public Baby(){}
    public void cry(){
        System.out.println("哭...");
    }
    public String toString() {
        return " 编号："+this.id+" 姓名："+ this.name;
    } 
}
public class Demo9 {
    public static void main(String[] args) {
        Baby b1 = new Baby();
        Baby b2 = new Baby(110, "李杰");
    }
}