第七周 Java学习

一 . sleep() 和 wait() 方法的区别

1) . 来源不同

<1>sleep()来自于Thread类中,表示线程睡眠 sleep(long time):时间毫秒值 

<2>wait()来自于Object类中,表示线程等待,需要被锁对象来访问

2) . 是否会释放锁

<1>sleep(long time):属于一个普通方法,调用该方法,不会去释放锁,只是导致线处于睡眠,当线程的睡眠时间到了,就继续执行线程

<2> wait():属于锁方法,被锁对象访问之后,会立即释放锁,才能够使用同步等待唤醒机制解决死锁问题,通过锁对象调用notify(),唤醒对方线程

3) . 这两个方法都会抛出异常(中断异常),都是属于本地方法,底层非Java语言实现

<1>当线程睡眠过程中,睡眠还没到,导致的睡眠状态被打断,就会出现InterruptedException

<2>当线程处于等待状态,被中断,就抛出这个异常

二 . 设计模式

结构型设计模式----代理模式 :

代理就是代理角色帮助真实角色完成一些事情.

(1)动态代理:反射中讲

(2)静态代理:通过代理角色帮助真实角色完成一些事情,真实角色只只专注于自己的事情;前提条件:

代理角色和真实角色必须是同一个接口

三 . 线程组

常用方法:

<1>ThreadGroup(String name): 构造一个新的线程组;

<2>public final ThreadGroup getThreadGroup():获取当前线程所属的线程组

<3>public final String getName():获取线程组名称

四 . 线程池

1 . 常用的线程池接口和类

<1>Executor: 线程池的顶级接口

<2>ExecutorService: 线程池接口,继承自Executor,可通过submit提交任务代码

<3>Executors: 工厂类,通过此类可以获得一个线程池

<4>通过Executors静态方法newFixedThreadPool(int nThreads)可获得固定数量线程池

<5>通过Executors静态方法newCachedThreadPool()获得动态数量线程池,不够会创建新的,没上限
 

2 . 常用方法

<1>Future<?> submit (Runnable task):  提交Runnable异步任务

<2> <T>Future<T> submit (Callable<T> task):  提交Callable异步任务,需执行Callable中的call方法

<3>void shutdown(): 关闭线程池

<4>Callable接口是JDK5加入,与Runnable接口类似,实现之后代表一个线程任务,Callable具有泛型

返回值,可以声明异常.

3 . Lock锁 ( 接口 )

jdk5以后提供Lock接口,比synchronized具有扩展性的功能,子实现类ReentrantLock:可重入互斥锁.

<1>public void lock()获取锁

<2>public void unlock()释放锁

处理异常: try...catch...finally(释放资源:代码一定执行/除非执行之前jvm退出了),捕获异常标准格式.
 

private Lock lock = new ReentrantLock();   创建重入锁对象
    @Override
    public void run() {
        while(true){
            lock.lock();   显示开启锁
            try{
                if(tickets > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+"正在出售第"+tickets--+"张票");
                }
            }finally {
                lock.unlock();   显示释放锁
            }

4 . 线程池中7大参数

<1>private volatile int corePoolSize: 线程池中的常驻核心线程数量

<2>private volatile int maximumPoolSize: 线程池能够容纳同时执行的最大线程数,值大于等于1。

<3>private volatile long keepAliveTime: 多余的空闲线程存活时间，当存活时间达到此值时，多余

的线程会被销毁直到只剩下corePoolSize个线程为止.

<4>private final BlockingQueue<Runnable>workQueue:任务队列，被提交但尚未被执行的任务

<5>private volatile ThreadFactory:  表示生成线程池中工作线程的线程工厂，用户创建新线程，一

般用默认即可

<6>private volatile RejectedExecutionHandler handler:拒绝策略，表示当线程队列满了并且工作

线程大于等于线程池的最大显示数(maxnumPoolSize)时如何来拒绝请求执行的runnable的策略.

<7>Timeunit unit: unit是keepAliveTime存活时间的计量单位.

五 . Timer:JavaSE的定时器

java.util.Timer :JavaSE的定时器:处理一次或者重复执行的任务(TimerTask:抽象类).

1 . 构造方法

public Timer():创建一个新的定时器,不是守护线程

2 . 成员方法

<1>public void cancel():取消定时器

<2>public void schedule(TimerTask task,long delay):经过多少毫秒后执行一次定时任务

<3>public void schedule(TimerTask task,long delay,long period): 经过delay毫秒后指向定时任务,

每经过period重复执行定时任务

<4>public void schedule(TimerTask task,Date time) :在指定时间的时候(精确到毫秒)执行定时任务

<5>public abstract void run():定时器要执行的操作,此方法为TimerTask方法

注意:TimerTask:抽象类不能实例化:自定义子类或者匿名内部类.
 

public class TestTimer {
    public static void main(String[] args) {
        Timer tm = new Timer();
        tm.schedule(new TimerTest(tm),2000,1000);
    }
}
public class TimerTest extends TimerTask {
    private Timer t;
    public TimerTest(Timer t){
        this.t = t;
    }
    @Override
    public void run() {
        System.out.println("执行任务...");
        t.cancel();
    }
}

六 . 设计模式之创建型模式

1 . 简单工厂模式

简单工厂模式:也称为"静态工厂方法模式",主要作用负责某些类的实例创建过程.

优点:通过工厂类完成各个类的对象的创建

弊端:当有新的类型增加,需要不断的修改工厂类,维护性难度大

public static Animal createAnimal(Object obj){ //向上转型:
        if(obj instanceof  Cat){
            return new Cat() ;
        }else if(obj instanceof  Dog){
            return new Dog() ;
        }else if(obj instanceof  Pig){
            return new Pig() ;
        }
        return  null ;
}
Animal animal = AnimalFactory.createAnimal(new Cat());
        if(animal!=null){
            animal.eat();
            animal.sleep();
        }
}

2 . 工厂方法模式

工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体

类实现。

优点:具体的工厂类负责创建当前具体的实例,结构层次很清晰,有具体类/工厂类/抽象工厂(接口)

弊端:有新的类型增加,需要编写外的代码,所有代码增加,导致工作量增加了

public class FactoryMethod {
    public static void main(String[] args) {
        Factory factory = new DogFactory() ;
        Animal animal = factory.createAnimal();
        animal.eat() ;
        animal.sleep() ;
        factory = new CatFactory() ;
        Animal animal2 = factory.createAnimal();
        animal2.eat() ;
        animal2.sleep() ;
    }
}
public interface Factory {  //抽象工厂(接口比抽象类还抽象)
    Animal createAnimal() ; //抽象方法:创建动物
}
public class CatFactory implements  Factory {
    @Override
    public Animal createAnimal() { //抽象类多态
        return new Cat();
    }
}

3 . 单例模式

单例:一个类的实例在内存中有且仅有一个.

分两种情况:饿汉式和懒汉式.

(1)饿汉式:永远不会出现安全问题的一种单例模式:

当类一加载,就创建了当前类对象,而且始终只有一个

<1>自定义具体类

<2>无参构造私有化,不让外界new对象

<3>在当前类成员位置创建自己本身对象

<4>当前类中提供一个对外公共静态的功能,返回值是他本身
 

public class Simple {
    private Simple(){}
    private static Simple s = new Simple();
    public static Simple method(){
        return s;
    }
}
public class TestSimple {
    public static void main(String[] args) {
        Simple s1 = Simple.method();
        Simple s2 = Simple.method();
        System.out.println(s1 == s2);  true
    }
}

(2)懒汉式:可能存在多线程安全问题的一种单例模式

<1>自定义具体类

<2>无参构造私有化,不让外界new对象

<3>需要在成员位置声明当前类型的变量

<4>提供一个对外公共静态访问方法,返回值是当前类本身

public class Simple {
    private Simple(){}
    private static Simple s;
    public static synchronized Simple method(){
        if(s == null){
            s = new Simple();
        }
        return s;
    }
}
public class TestSimple {
    public static void main(String[] args) {
        Simple s1 = Simple.method();
        Simple s2 = Simple.method();
        System.out.println(s1 == s2);
    }
}

七 . Runtime类

Runtime类:每个Java程序都有自己的运行环境,通过Runtime创建的实例表示:当前系统的运行环境.

原码使用的是饿汉式
public class TestRuntime {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();创建当前运行环境的实例
    }
}

常用方法:

<1>public int availableProcessors():  获取计算机cpu的处理器数量

<2>public Process exec(String command) throws IOException:  操作指令

<3>runtime.exec("shutdown -s -t 300") ;关机指令

八 . 递归

1 . 递归的概念

递归:方法调用方法本身的一种现象;而不是方法嵌套方法.

2 . 递归思想

<1>必须定义一个方法(函数)

<2>有一定的规律

<3>必须有出口条件(结束条件),如果没有结束条件就是死递归.

注意:构造方法不存在递归.

3 . 递归例题:求5的阶乘

public class TestDiGui {
    public static void main(String[] args) {
        int result = method(5);
        System.out.println(result);
    }
    public static int method(int n){
        if(n == 1){
            return 1;   出口条件
        }else{
            return n * method(n-1);
        }
    }
}

九 . File类

File:描述的是一个文件/目录的抽象路径名的形式.

1 . 构造方法

<1>File(String pathname):  直接描述地址路径

<2>File(File parent, String child):  从父抽象路径名和子路径名字符串创建新的 File实例

<3>File(String parent, String child):  从父抽象路径名字符串和子路径名字符串创建新的 File实例

2 . 成员方法

<1>public boolean createNewFile() throws IOException:创建文件,如果文件不存在,就会自动创建,

创建成功,返回true

<2>public boolean mkdir():创建文件夹(目录),如果文件夹不存在,则自动创建;创建成功,返回true,否

则false;

<3>public boolean mkdirs():针对带多级目录创建;如果父目录不存在,会自动创建

<4>public boolean delete():删除文件或者目录,删除必须为空目录

<5>public boolean isDirectory():  判断是否是文件夹

<6>public boolean isFile()  :判断是否是文件

<7>public String getName():获取当前抽象路径名表示的文件或者文件夹的名称

注意:如果没有带盘符,创建的文件或者文件夹相对路径:默认在当前项目下

3 . 高级功能

<1>public File[] listFiles():获取某个目录下的所有文件以及文件夹的File数组

<2>public String[] list():返回由 File 对象表示目录中所有文件和子目录名称组成的字符串数组，如

果调用的 File 对象不是目录，则返回 null;此方法返回的数组中仅包含文件名称，而不包含路径。

<3>public String[] list(FilenameFilter filter): 该方法的作用与 list() 方法相同，不同的是返回数组中

仅包含符合 filter 过滤器的文件和目录，如果 filter 为 null，则接受所有名称.

<4>public File[] listFiles(FilenameFilter filter):  使用文件名称过滤器作为参数传递:

假设希望只列出目录下的某些文件，这就需要调用带过滤器参数的 list() 方法。首先需要创建文件

过滤器，该过滤器必须实现 FilenameFilter接口，并在 accept() 方法中指定允许的文件类型。

boolean accept(File dir,String name):是否将name文件名称添加抽象类路径名所表示的列表中,取

决于返回值 true,表示将name添加到文件过滤列表中,否则false,不添加.

public class TestFile {
    public static void main(String[] args) {
        File file = new File("D:\\");
        File[] files = file.listFiles();
        if(files != null){
            for(File f : files){
                if(f.isFile()){
                    if(f.getName().endsWith(".jpg")){
                        System.out.println(f.getName()+"---"+f.delete());
                    }
                }
            }
        }
    }
}

十 . IO 流

1. 流的分类

(1)按方向

<1>输入流:将存储设备中的内容读入到内存中

<2>输出流:将内存中的内容写入到存储设备中

(2)按单位

<1>字节流:以字节为单位,可以读写所有数据

<2>字符流:以字符为单位,只能读写文本数据

(3)按功能

<1>节点流:具有实际传输数据的读写功能

<2>过滤流:在节点流的功能之上增强功能

2. 文件输出流的创建及写数据

<1>public FileOutputStream(String name) throws FileNotFoundException:创建文件输出流

<2>public FileOutputStream(String pathname,boolean append):如果第二个参数为true,则自动在

后面追加

<3>void write(byte[] b):写入一个字节数组

<4>void write(byte[] b, int off, int len):写入字节数组的一部分

<5> void write(int b ):写入单个字节

<6>close():释放资源

3.文件输入流的创建及读数据

<1>public FileInputStream(String name) throws FileNotFoundException:创建文件字节输入流对象

<2>abstract int read():一次读取一个字节,返回的读取的字节数,如果达到文件末尾返回-1

<3>int read(byte[] b)  :一次读取一个字节数组

注意:将文件内容打印在控制台: 如果文件中有中文,出现乱码,原因就是我们对读取的字节数强转为

char,一个英文对应一个字节,但是一个中文8个字节,拼接不上导致乱码.

windows操作系统中:写入数据的时候,换行符号 "\r\n"

4.异常处理

(1)throws:抛出---抛在方法声明上,谁调用这个方法,谁就是调用者,通过调用者进行处理;

(2)try...catch...finally:捕获----通过业务逻辑代码(业务层代码:service层)

(3)try...catch;   try...catch...catch...catch;    try...finally

try{
    可能出现问题的代码;---一旦这有问题:Jvm 就会创建异常对象
 
}   catch   (异常类名 e)  { //如果和当前异常类名匹配了
    处理异常
    System.out.println("数组角标越界了") ;
    e.printStackTrace() ;//可以看到你自己写的代码哪块出错了以及底层原码
}finally{
 
    释放资源
}

5.字节缓冲流

BufferedOutputStream:字节缓冲输出流(别名 "字节高效流");这个流仅仅是在内部提供了一个缓冲

区(字节数组),针对文件的输出并且同时写入数据使用的还是底层流OutputStream.

(1)构造方法

public BufferedOutputStream(OutputStream out):构造一个默认的缓冲区大小,通过底层流进行输.

使用字节缓冲输出流写数据：一次写1个字节数组
public class Test03 {
    public static void main(String[] args) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
        bos.write("helloword".getBytes());
        bos.close();
    }
}

第四种：使用字节缓冲输入流一次读取1个字节数组
public class Test04 {
    public static void main(String[] args) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("TestInt.java"));
        byte[] bytes = new byte[1024];
        int n = 0;
        while((n = bis.read(bytes))!= -1){
            System.out.println(new String(bytes,0,n));
        }
        bis.close();
    }
}

6.合并流

SequenceInpuStream----是InputStream的子类:它这个类只能操作源文件

<1>public SequenceInputStream(InputStream s1,InputStream s2):将两个字节输入流对象指向的

文件进行合并

<2>public SequenceInputStream(Enumeration<? extends InputStream> e)

合并两个文件
public class Test05 {
    public static void main(String[] args) throws IOException {
         FileInputStream fis1 = new FileInputStream("GetChar.java");
        FileInputStream fis2 = new FileInputStream("TestInt.java");
        SequenceInputStream sis = new SequenceInputStream(fis1,fis2);将两个文件封装进去
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.java"));
        byte[] bytes = new byte[1024];
        int n = 0;
        while((n = sis.read(bytes))!= -1){
            bos.write(bytes,0,n);
            bos.flush();
        }
        bos.close();
        sis.close();
    }
}

合并多个文件
public class Test05 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis1 = new FileInputStream("GetChar.java");
        FileInputStream fis2 = new FileInputStream("TestInt.java");
        FileInputStream fis3 = new FileInputStream("Test03.java");
        Vector<InputStream> v = new Vector<>();
        v.add(fis1);
        v.add(fis2);
        v.add(fis3);
        Enumeration<InputStream> elements = v.elements();
        SequenceInputStream sis = new SequenceInputStream(elements);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.java"));
        byte[] bytes = new byte[1024];
        int n = 0;
        while((n = sis.read(bytes))!= -1){
            bos.write(bytes,0,n);
            bos.flush();
        }
        bos.close();
        sis.close();
    }
}

7.Reader类

Reader:字符流,为抽象类

(1)字符输入流

<1>InputStreamReader(InputStream in) :使用平台默认的字符集进行解码,里面包装的字节流

<2>InputStreamReader(InputStream in,String charsetName):使用指定的字符集进行解码

<3>read()

<4>read(char[] chs)
 

public class Test06 {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");
        int c = 0;
        while((c = isr.read()) != -1){
            System.out.print((char)c);
        }
        isr.close();
    }
}

(2)字符输出流

<1> OutputStreamWriter(OutputStream out) :使用平台默认的编码字符集进行编码--->写入数据

<2>OutputStreamWriter(OutputStream out,String charsetName )使用指定的编码字符集进行编码
 

OutputStreamWriter oos = new OutputStreamWriter(new FileOutputStream("oos.txt"),"GBK") ;
oos.write("hello,字符流");
oos.close() ;

8.字符缓冲流

(1)字符缓冲输入流

<1>BufferedReader(Reader in)

<2>特有功能:String readLine() 读取一行内容.

(2)字符缓冲输出流

<1>BufferedWriter(Writer out)  :提供默认缓冲区大小,默认值足够大:8192个长度(底层是一种字符数组)

<2>特有功能:public void newLine() throws IOException :写入行的分隔符号
 

public class Test06 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));//创建字符缓冲输入流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));//创建字符缓冲输出流对象
        String line = null;
        while((line = br.readLine())!=null){
            bw.write(line);
            bw.newLine();//换行
            bw.flush();
        }
        bw.close();
        br.close();
    }
}

十一.Lock和synchronized的区别

(1)synchronized是一个关键字:底层实现是一些指令:监视器锁(monitor),是一种悲观锁(独占锁),当

某个线程持有这个锁的时候,其他线程访问不到;应用场景:少量同步代码使用synchronized;默认的锁

的释放是需要等待执行完毕同步方法或者同步代码块

(2)Lock是接口,基于子实现类(ReentrantLock)进行实现:可重入的互斥锁,底层实现原理采用CAS(比

较和交换)算法,本质属于乐观锁;应用场景:针对大量的同步代码使用Lock;本身就提供具体的功

能,lock()/unlock().

十二.序列化与反序列化

1.序列化

(1)序列化:就是在将Java对象变成一种流数据,他们里面的数据存储流中,就可以在网络中传输.

前提条件:实体类必须实现标记接口序列化.

(2)构造方法:public ObjectOutputStream(OutputStream out)

(3)成员方法:public final void writeObject(Object obj) throws IOException:写入一个实体对象
 

            创建序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt")) ;
Person p = new Person() ;
p.name = "张三" ;
p.age = 21 ;
oos.writeObject(p) ;
oos.close() ;

2.反序列化

(1)反序列化:就是将流数据(存储的一些相关的实体类数据)-----还原成Java对象

(2)构造方法:public ObjectInputStream(InputStream in):将文件中的数据进行读取

(3)成员方法:public final Object readObject()将流中的数据读取出来,解析成对象

            创建反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt")) ;
Object object = ois.readObject();
System.out.println(object) ;
ois.close() ; 关闭资源

十三.Properties属性集合类

java.util.Propertis:属性集合类(属性列表)是一个Map,但是没有泛型,键和值都是String

1.特有功能

<1>public Object setProperty(String key,String value):添加键和值

<2>public Set<String> stringPropertyNames():获取所有键的集合

<3>public String getProperty(String key):获取键对应的值

<4>public void store(Writer writer, String comments):将属性列表中的内容保存指定的文件中

<5>public void load(Reader reader):将文件中的内容加载属性列表中

2.专属遍历方式

        专属遍历方式
Properties p = new Properties();
p.setProperty("张三","23");
p.setProperty("李四","34");
p.setProperty("王五","54");
Set<String> strings = p.stringPropertyNames();
for(String key : strings){
    String value = p.getProperty(key);
    System.out.println(key+"-"+value);
}

3.典型功能

        将属性列表中的内容保存指定文件中
public class Test03 {
    public static void main(String[] args) throws IOException {
        Properties p = new Properties();
        p.setProperty("张三","23");
        p.setProperty("李四","34");
        p.setProperty("王五","54");
        p.store(new FileWriter("b.txt"),"姓名列表"); 
    }
}

    将文件中内容加载进来,将属性列表中内容进行遍历
public class Test03 {
    public static void main(String[] args) throws IOException {
        Properties p = new Properties();
        p.load(new FileReader("a.txt"));
        Set<String> strings = p.stringPropertyNames();
        for(String key : strings){
            String value = p.getProperty(key);
            System.out.println(key+ "-"+value);
        }
    }
}

Class c = Test01.class ; 1)获取当前类的字节码文件对象
ClassLoader classLoader = c.getClassLoader(); 2)获取类加载器
        3)通过类加载获取当前src目录下面的配置文件所在的输入流对象
InputStream inputStream = classLoader.getResourceAsStream("name.properties"); 
        创建Properties
Properties prop = new Properties() ;
prop.load(inputStream);
System.out.println(prop) ;

十四.网络编程

1.UDP协议方式发送端与接收端思路

(1)UDP发送端思路

<1>创建UDP发送端的Socket对象

<2>创建数据，并把数据打包

<3>调用Socket对象的发送方法发送数据包

<4>释放资源

public class Receive{
    public static void main(String[] args) throws IOException {
            1)创建接收端的Socket对象DatagramSocket
        DatagramSocket ds = new DatagramSocket(10086) ;
        while(true){
            byte[] bytes = new byte[1024] ; 创建一个接收容器: 自定义一个缓冲区byte[]
            int length = bytes.length ;
            DatagramPacket dp = new DatagramPacket(bytes,length) ; 创建数据包报
            ds.receive(dp);  3)接收
                4)解析接收容器中的真实内容
            String str = new String(dp.getData(),0,dp.getLength()) ;  
            String ip = dp.getAddress().getHostAddress() ;
            System.out.println("data from "+ip +",content is :"+str) ;
        }
        ds.close() ;
    }
}

(2)UDP接收端思路

<1>创建接收端的Socket对象

<2>创建一个数据包(接收容器)

<3>调用Socket对象的接收方法接收数据

<4>解析真实数据

<5>展示ip和发送的内容

public class Send{
    public static void main(String[] args) throws Exception {
            1)创建UDP发送端的Socket对象
        DatagramSocket ds = new DatagramSocket() ;
            创建一个BufferedReader流对象:键盘录入
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
        String line = null ;
         while((line=br.readLine())!=null){
            if("886".equals(line)){
                break ;
            }
                2)创建数据报包
            DatagramPacket dp = new DatagramPacket(line.getBytes(), line.getBytes().length,
            InetAddress.getByName("10.12.159.190"),10086) ;
                3)发送
            ds.send(dp) ;
        }
                4)释放资源
        ds.close() ;
    }
}
        
       

2.TCP/IP服务器端与客户端的实现步骤

(1)TCP/IP 客户端的实现步骤

<1>创建客户端的Socket对象

<2>获取客户端所在的通道内的字节输出流OutputStream

<3>给客户端通道内的流中写入数据

<4>释放客户端的资源对象

public class Client{
    public static void main(String[] args) throws IOException {
            1)创建客户端的Socket对象
        Socket socket = new Socket("10.12.159.190",10010) ;
            2)获取客户端所在的通道内的字节输出流
        OutputStream out = socket.getOutputStream();
            3)写数据:给通道流中写入数据
        out.write("helloworld".getBytes());
            4)释放资源
        socket.close() ;
    }
}

(2)TCP/IP服务器端的步骤实现

<1>创建服务器端的Socket对象

<2>监听客户端的连接

<3>获取连接的客户端的通道内的输入流

<4>展示数据

<5>释放资源

public class ServerDemo {
    public static void main(String[] args) throws IOException {
            1)创建服务器端的Socket对象
        ServerSocket ss = new ServerSocket(10010) ;
            2)监听客户端的连接,一旦监听到了,就获取到客户端的Socket
        Socket socket = ss.accept();
            3)获取连接的客户端的通道内的输入流,读取数据
        InputStream inputStream = socket.getInputStream();
            4)读:一次读取一个字节数组
        byte[] bytes = new byte[1024] ;
        int len = inputStream.read(bytes);
        String str = new String(bytes,0,len) ;
        String ip = socket.getInetAddress().getHostAddress(); 获取ip地址
            5)展示数据
        System.out.println(ip + str);
        ss.close() ; 释放资源
    }
}

3.UDP和TCP的区别

(1)TCP面向连接；UDP是无连接的，即发送数据之前不需要建立连接

(2)TCP要求的系统资源较多，UDP较少

(3)TCP提供可靠的服务.通过TCP连接传送的数据不丢失,不重复,且按序到达;UDP存在安全问题

十五.throw和throws的区别

1)使用位置不同

 throws:跟在方法上,可以跟多个异常类名,中间逗号隔开

throw:方法体的语句中,后面的异常对象  new XXXExeption() 

2)处理方式不同

throws:它的处理交给调用者处理,谁调用这个带throws的方法,谁就需要进行处理

throw:它的处理交给方法体中逻辑语句处理;

3)是否出现异常的可能性

throws:可能出现异常

throw:表示执行某段代码一定会出现这个异常
 

十六.获取一个类字节码文件

<1>Object类的getClass()-->Class    ---class 包名.类名

<2>任意Java类型的class属性

<3>public static Class forName(String className)

Class.forName("包名.类名") ; 第三种方式:反射中Class使用这种