java基础-day19-内部类.socket编程

内部类

如果B类的存在只是为了让A类使用，此时，就可以把B类作为A的内部类。
形式：

class A{//外部类
	class B{//内部类：可以看做是外部类的成员
		      // 变量+方法
	}
}

位置不同，内部类的名字和作用不同
如果在成员位置(类里方法外) - 成员内部类
如果在方法里 - 局部内部类 不用
匿名内部类 常用

//这个类用来 定义 内部类
public class InnerClass {
    private int age = 10 ;
    public void save() {
        System.out.println("InnerClass.save()");
        //特点2：外部类想要使用内部类成员--必须创建内部类对象
        Inner in2 = new Inner();
        in2.get();
        System.out.println(in2.name);
    }
    //成员内部类
    class Inner{
        String name = "皮皮霞";
        public void get() {
            //特点1：内部类可以使用  所有  外部类成员
            save();
            System.out.println(age);
            System.out.println("惊雷！");
        }
    }
}
//这个类用来 测试 内部类
public class Test1_InnerClass {
    public static void main(String[] args) {
        //1、想办法 使用 内部类的资源 - 创建内部类对象
        //外部类.内部类 变量名=外部类对象.内部类对象
        InnerClass.Inner in = new InnerClass().new Inner();
        in.get();
        System.out.println(in.name);
    }
}

被 private 修饰内部类

//这个类用来 定义 private 修饰的内部类
public class Test1 {
    private int age = 10 ;
    public void save() {
        System.out.println("InnerClass.save()");
        //特点2：外部类想要使用内部类成员--必须创建内部类对象
        Inner in2 = new Inner();
        in2.get();
        System.out.println(in2.name);
    }
    //成员内部类
    private class Inner{
        String name = "哈哈";
        public void get() {
            //特点1：内部类可以使用  所有  外部类成员
            //       save();
            System.out.println(age);
            System.out.println("惊雷！");
        }
    }
}
//这个类用来 测试 内部类
public class Test1_InnerClass {
    public static void main(String[] args) {
        //1、想办法 使用 内部类的资源 - 创建内部类对象
        //外部类.内部类 变量名=外部类对象.内部类对象
        //    InnerClass.Inner in = new InnerClass().new Inner();
        //    in.get();
        //    System.out.println(in.name);

        //2、当内部类被private修饰后，我们无法直接访问内部类资源
        //需要访问外部类的资源来间接实现访问内部类的资源
        InnerClass in = new InnerClass();
        in.save();
    }
}

被 static 修饰的内部类

public class Test2 {
    static private int age = 10 ;
    public void save() {
        System.out.println("InnerClass.save()");
        //特点2：外部类想要使用内部类成员--必须创建内部类对象
        Inner in2 = new Inner();
        in2.get();
        System.out.println(in2.name);
    }
    //成员内部类
    static class Inner{
        static int sum = 30 ;
        String name = "哈哈";
        public void get() {
            //特点1：内部类可以使用  所有  外部类成员
            //       save();
            System.out.println(age);
            System.out.println("惊雷！");
        }
    }
}
public class Test1_InnerClass {
    public static void main(String[] args) {
        InnerClass2.Inner in2 =new InnerClass2.Inner();
        in2.get();
        System.out.println(in2.name);
        //4、静态的内部类里的静态资源
        System.out.println(  InnerClass2.Inner.sum);
    }
}

匿名内部类

public class Test3_Inner {
    public static void main(String[] args) {
        //2、接口可以创建对象吗？--不可以！！
        //但是， 如果同时使用了匿名对象和匿名内部类是可以直接new的，就相当于创建了接口的实现类
        //匿名的好处是：用起来方便。坏处是：一次只执行一个任务。
        new Inter1() {
            @Override
            public void save() {
                System.out.println("save()");
            }
            @Override
            public void get() {
                System.out.println("get()");
            }
        }.save();//3、触发方法的执行
        //5、抽象类直接 new可以吗？--- 不可以！！
        new AbstractDemo() {
            @Override
            public void sleep() {
                System.out.println("sleep()");
            }
        }.sleep(); //6、触发方法
    }
}
//4、定义抽象类
abstract class AbstractDemo{
    public void eat() {
        System.out.println("eat()...");
    }
    abstract public void sleep()  ;
}
//1、定义接口
interface Inter1{
    void save();
    void get();
}

Socket 编程

服务器端：接受客户端发来的连接请求 + 组织数据给客户端做出响应

ServerSocket
ServerSocket(int port)   创建对象
Socket accept()         侦听并接受到此套接字的连接
void    close()         关闭此套接字

客户端：不断的连接服务器 + 接收服务器发来的响应数据

Socket
Socket(String host,int port)  创建一个流套接字并将其连接到指定主机上的指定端口号
void close()                  关闭此套接字

服务器端接受客户端发来的 hello，并给客户端响应 world
注：先启动服务器端，再启动客户端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//这个类用来   表示  Socket编程的 服务器端
public class Server {
    public static void main(String[] args) throws IOException {
        //1、创建服务器对象，表示在该端口上，等待客户端的连接请求。
        //参数是端口号：默认0~65535，其中0~1024被系统占用
        ServerSocket server = new ServerSocket(8000) ;
        //2、开始接受客户端的请求，并建立了数据传输通道Socket
        Socket socket = server.accept();
        System.out.println("恭喜您，连接成功！！");
        //3、读取客户端发来的数据  -- in
        InputStream in = socket.getInputStream();
        //客户端发来5个字节，循环读取5次
        for (int i = 0; i < 5; i++) {
            //       int b = in.read();//不能读到整数，我就要字符
            char c = (char)in.read();
            System.out.print(c);//同行展示
        }
        //4、服务器给客户端发送数据--out
        OutputStream out = socket.getOutputStream() ;
        //5、开始写出数据
        out.write("world".getBytes());
        out.flush();
    }
}
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
//这个类用来   表示  Socket编程的 客户端
public class Client {
    public static void main(String[] args) throws IOException {
        //1、创建客户端对象，连接指定的服务器
        //参数是服务器的ip和服务器的端口
        //ip地址如果是访问你这台电脑ip是固定值127.0.0.1   /  localhost
        //ip地址如果是在工作中，就应该写真实的服务器的ip
        Socket socket = new Socket("127.0.0.1" , 8000);
        //2、给服务器发送数据 -- out
        OutputStream out = socket.getOutputStream() ;
        //3、开始写出数据
        out.write("hello".getBytes());//参数需要的是byte[]
        out.flush();
        //4、客户端读取服务器发回来的数据--in
        InputStream in = socket.getInputStream() ;
        //5、开始正式读取数据
        for (int i = 0; i < 5; i++) {
            char c = (char)in.read();
            System.out.print(c);
        }
    }
}