JAVA基础知识六（网络编程、反射）

最新推荐文章于 2022-05-04 20:21:13 发布
最新推荐文章于 2022-05-04 20:21:13 发布
阅读量158 收藏 1
点赞数 1
分类专栏： 技术 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuan_kk0321/article/details/119246206
版权

十、网络编程

计算机网络：

总结：将地理位置不同的计算机设备进行连接，实现数据的共享。

网络编程：

总结：在已有网络的环境下，按照规定实现接收和发送数据即可。

中间过程对于我们不需要关注。

网络模型：

1.网络编程三要素：

1. IP地址：

计算网络中，每个计算机的唯一标识。

IPV4： 由32bit组成，即4个字节，每个字节范围0~255，4个数字组成。

IPV6： 有128bit组成，即16个字节，由8组十六进制数组成

DNS：域名解析器 记忆IP地址不方便，出现了使用名称的表示方式

负责解析名称的，最终转为IP地址形式。

本地回还地址：127.0.0.1 localhost

2. 端口号：

计算中每个应用程序的标识，范围是0~65535 ，其中0~1023被系统占用

3. 协议：

双方通信的规则。

常用：UDP 和 TCP

UDP：

用户数据报包协议

面向无连接，不需要与接收端建立连接，直接发送数据。

不可靠协议，因为数据有可能会丢失，效率高。

如：cts、会议软件、发快递

TCP：

传输控制协议

面向有连接，必须双方建立连接受才能进行数据传输。

可靠协议，不会有数据丢，效率低。

确定连接：

三次握手模式确定连接。

A 发 B 接

第一次，A--->B

第二次：B接到，并给A回信息

第三次：A接到

比如：打电话

InetAddress

在java中是面向对象思想，因此表示计算机唯一标识的这些数字也看成是一类事物，因此就有对应的对象进行描述--InetAddress。

java.net包。

方法：

InetAddress getByName(String host) ：根据host获取InetAddress对象

host：可以是主机名或主机的IP地址形式

InetAddress getLocalhost() : 获取本地主机的InetAddress对象

String getHostName(): 获取主机名

String getHostAddress(): 获取主机地址

2.UDP

UDP协议

//创建InetAddress对象
//没有构造方法，只有几个静态方法可以返回这一个InetAddress 类型的对象
    InetAddress inetAddress = InetAddress.getByName("baidu.com");//可以是机器名称，可以是IP地址
    System.out.println(inetAddress);
    String hostName = inetAddress.getHostName();
    System.out.println(hostName);

1.发送

两端：接收端 和 发送端

端点对象： Datagramsocket

包对象： DatagramPacket

发送端：

1.创建Datagramsocket对象

2.创建DatagramPacket对象，并将数据和接收端信息封装到对象中

3.调用send方法发送

4.关闭

        //创建端点对象
        DatagramSocket ds = new DatagramSocket();
        //1.创建包对象
        //2.设置接收端信息，内容信息
        byte[] massage = "你好".getBytes();
        int len = massage.length;
        InetAddress ip = InetAddress.getByName("local");
        int port = 9999;
        //设置四个参数，发送的信息（字节数组类型）、长度、对方的ip、对方的端口号
        DatagramPacket dp = new DatagramPacket(massage,len,ip,port);
        //3.发包
        ds.send(dp);
        System.out.println("数据已发送");
        //4.关闭
        ds.close();

2.接收

接收段：

1.创建Datagramsocket对象，必须指定端口，要与发送端中的包中的端口号要一致

2.创建DatagramPacket对象，用于接受数据

3.调用receive()方法接包

4.拆包

5.关闭

        //1.创建对象并且设置端口号
        DatagramSocket ds = new DatagramSocket(9999);
        //2.准备接收
        //创建数组准备接收
        byte[] by = new byte[1024];
        //获取数组长度
        int len = by.length;
        DatagramPacket dp = new DatagramPacket(by,len);
        //使用这个包获取
        ds.receive(dp);
        byte[] data = dp.getData();
        String s = new String(data,0,dp.getLength());
        System.out.println(s);
        //关闭
        ds.close();

案例实现（网聊）：

    //先发后收，设置死循环，特定字符串退出
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        DatagramSocket ds = new DatagramSocket();
        while(true){
            //发
            System.out.print("小明说：");
            String s = sc.next();
            byte[] by = s.getBytes();
            DatagramPacket dp = new DatagramPacket(by,by.length, InetAddress.getLocalHost(),8888);
            ds.send(dp);
            if ("exit".equals(s)){
                System.exit(0);
            }
            //收
            byte[] by1 = new byte[1024];
            DatagramPacket dp1 = new DatagramPacket(by1,1024);
            ds.receive(dp1);
            byte[] data = dp1.getData();
            String s1 = new String(data,0,dp1.getLength());
            System.out.print("小红说：");
            System.out.println(s1);
        }
    }
    //现接收，后发送   
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        DatagramSocket ds = new DatagramSocket(8888);
        while (true){
            //收
            byte[] by = new byte[1024];
            DatagramPacket dp = new DatagramPacket(by,1024);       //创建包
            ds.receive(dp);             //使用这个包接收数据
            byte[] data = dp.getData();     //创建字节数字并使用包获得数据
            String s = new String(data,0,dp.getLength());       //转换为字符串
            if ("exit".equals(s)){
                System.exit(0);
            }
            System.out.print("小明说："+s);
            System.out.println();
            //发
            System.out.print("小红说：");
            String s1 = sc.next();
            byte[] by1 = s1.getBytes();
            DatagramPacket dp1 = new DatagramPacket(by1,by1.length, dp.getAddress(),dp.getPort());
            ds.send(dp1);
        }
    }

3.广播和组(多)播

UDP协议： 单播 广播 组播

广播：

一个主机可以与该网络内中的所有主机进行数据共享。

广播地址：255.255.255.255

        //广播发送
        public static void main(String[] args) throws IOException {
        //创建对象
        DatagramSocket ds = new DatagramSocket();
        //准备发送
        //创建数组
        byte[] by = "你好".getBytes();
        int len = by.length;
        InetAddress ip = InetAddress.getByName("255.255.255.255");
        int port = 8080;
        DatagramPacket dp = new DatagramPacket(by,len,ip,port);
        ds.send(dp);
        System.out.println("发送完毕");
        ds.close();
        }
        //广播接收
        public static void main(String[] args) throws IOException {
        //创建对象
        DatagramSocket ds = new DatagramSocket(8080);
        //准备接收
        byte[] by = new byte[1024];
        DatagramPacket dp = new DatagramPacket(by,1024);
        ds.receive(dp);
        //拆包
        byte[] data = dp.getData();
        int len = dp.getLength();
        System.out.println("对方发的内容是："+ new String(data,0,len));
        System.out.println("对方的端口号是"+ dp.getPort());
        System.out.println("对方的地址是："+ dp.getAddress().getHostName());
        }

4.组播

        //发送
         public static void main(String[] args) throws IOException {
        //创建对象
        MulticastSocket ms = new MulticastSocket();
        //准备发送
        byte[] by = "网络组播".getBytes();
        int len =  by.length;
        InetAddress ip = InetAddress.getByName("224.0.0.23");
        int port = 8080;
        DatagramPacket dp = new DatagramPacket(by,len,ip,port);
        //发送
        ms.send(dp);
        //关闭
        ms.close();
        }
        //接收
    public static void main(String[] args) throws IOException {
        //创建对象
        MulticastSocket ms = new MulticastSocket(8080);
        InetAddress ip = InetAddress.getByName("224.0.0.23");   //小组ip
        //加入组播
        ms.joinGroup(ip);
        while (true){
            //准备接收
            byte[] by = new byte[1024];
            DatagramPacket dp = new DatagramPacket(by,1024);
            ms.receive(dp);
            //显示数据
            byte[] data = dp.getData();
            int len = dp.getLength();
            System.out.println(new String(data,0,len));
            System.out.println("对方的ip是："+ dp.getAddress().getHostName());
            System.out.println("对方的端口号是：" + dp.getPort());
        }
    }

3.TCP

特点：面向有连接，可靠协议。

两端：客户端和服务端。

客户端：Socket 服务端：ServerSocket

客户端：

1.创建套接字对象，邦定地址，端口号（服务端地址和端口号），socket参数一定要写服务端的ip和端口

2.获取输出流对象，向服务端写数据

3.关闭套接字

1.数据的传输与接送

        //发送
        public static void main(String[] args) throws IOException {
        //客户端发消息
        Socket s = new Socket("localhost",8888);
        //读入写出，获取输出流对象
        OutputStream os = s.getOutputStream();
        os.write("你好".getBytes());
        System.out.println("发送完毕");
        //关闭
        s.close();
        os.close();
        }

服务端：

1.创建服务端端点对象，并邦定端口号（与客户端的端口号要一致）

2.获取Socket对象（侦听要连接的客户端）

3.获取输入流对象，读取客户端数据

4.关闭服务端端点对象

ServerSocket构造方法：

        //接收
        public static void main(String[] args) throws IOException {
        //创建套接字对象
        ServerSocket ss = new ServerSocket(8888);
        //创建侦听器，识别来源信息
        Socket s = ss.accept();
        //读入写出，创建输入流对象
        InputStream is = s.getInputStream();
        //创建数组准备接收
        byte[] by = new byte[1024];
        int len = is.read(by);
        //输出
        String s1 = new String(by,0,len);
        System.out.println(s1);
        System.out.println("对方的ip是"+ s.getInetAddress().getHostName());
        System.out.println("对方的端口号是："+ s.getPort());
        //关闭
        is.close();
        s.close();
        }

2.文件的传输与接送

    //客户端发文件
    public static void main(String[] args) throws IOException {
        //上传文件---客户端
        Socket s = new Socket("localhost",9090);
        //获取输出流对象
        OutputStream os = s.getOutputStream();
        //定义一个输入流，关联要上传的文件
        FileInputStream fis = new FileInputStream("E:\\0622系统班\\day24\\a.txt");
        byte[] buf = new byte[1024];
        int len ;
        while((len = fis.read(buf)) != -1){
            os.write(buf,0,len);
        }
        //客户端清楚数据都已发送，但是服务端并不知道数据都已接收
        //需要客户端给服务端发送一个结束的标志
        //发送结束标志给服务端
        s.shutdownOutput();
        //关闭流
        fis.close();
        System.out.println("--------文件已发送------------");
        //读取服务单回送的消息
        //获取输入流对象
        InputStream is = s.getInputStream();
        byte[] by = new byte[1024];
        int num = is.read(by);
        System.out.println(new String(by,0,num));
​
        //关闭
        s.close();
    }
        //服务端
        public static void main(String[] args) throws IOException {
        //上传文件---服务端
        ServerSocket ss = new ServerSocket(9900);
        Socket s = ss.accept();
        //定义输出流，用于保存客户端送的文件数据
        //文件重名问题
        String name = UUID.randomUUID().toString().replace("-", "");
        File file = new File("F:\\IdeaProjects\\0622\\day23\\"+name+"txt");
        if (file.exists()){
            name = UUID.randomUUID().toString().replace("-", "");
            file = new File("F:\\IdeaProjects\\0622\\day23\\"+name+"txt");
        }
        //获取输入流对象
        InputStream is = s.getInputStream();
        byte[] buf = new byte[1024];
        int len;
        //read是一个阻塞式方法，客户端并没有发送结束标志，就会一直等待读取数据
        //因此循环不结束
        while((len = is.read(buf)) != -1){
            fos.write(buf,0,len);
        }
        //关闭定义的流
        fos.close();
        System.out.println("-----------------文件已接收-----------------");
        //客户端回送消息
        //获取输出流对象
        OutputStream os = s.getOutputStream();
        os.write("文件已上传成功".getBytes());
​
        //关闭
        s.close();
        ss.close();
    }

3.多线程下的服务端

public class TCPThreadServer {
    public static void main(String[] args) throws IOException {
        //多线程模式下的服务端
        ServerSocket ss = new ServerSocket(8080);
        while(true){
            //侦听连接的客户端
            Socket s = ss.accept();     //侦听一定要放到循环里边，因为发送者是很多人，每个发送者的信息不一样
            Thread  t = new Thread(new MyRun(s));
            t.start();
        }
​
        //ss.close();
    }
}
​
class MyRun implements  Runnable{
    private Socket s;
    public MyRun(Socket s){
        this.s = s;
    }
    @Override
    public void run() {
        try {
            //获取输入流对象
            InputStream is = s.getInputStream();
            byte[] buf = new byte[1024];
            int len = is.read(buf);
            System.out.println("客户端发送的数据是："+new String(buf,0,len));
            System.out.println("客户端的端口号是："+s.getPort());
            System.out.println("客户端的地址是："+s.getInetAddress().getHostAddress());
            System.out.println("------------------------------------------");
            //回送消息
            s.getOutputStream().write("数据已收到".getBytes());
        }catch (IOException e){
            System.out.println(e);
        }finally {
            if(s != null) {
                try {
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

十一、反射

1.类加载

1.类加载过程

概念: 将class文件从磁盘到内存中，并获取class文件中的数据，对这些数据进行解析，转换等操作，最终成为可使用的java类型，这个过程叫做---类加载过程。

这些过程中： 加载、连接、初始化、使用、卸载

加载：

将class文件从磁盘内存中，为当前这个class文件自动创建一个Class对象。

连接：

验证class文件中内部结构，将一些符号名称转为对应的数据..

初始化：

对类变量进行初始化。

2.什么时候类加载

1.创建该类型对象

2.访问静态成员时

3.获取Class对象时

4.创建子类对象时，父类class文件

5.执行java.exe命令

3.类加载器

概念：类加载器是一个对象，作用就是用来加载class文件的，从磁盘到内存，

并为该class文件，创建一个Class对象。

分类：

Bootstrap ClassLoader ：引导类加载器 父

Extension ClassLoader： 扩展类加载器 子

Application ClassLoader：系统类加载器 子子

自定义类加载器，定义类继承ClassLoader。

加载类时，采用的是一种委托机制。

加载类时，会逐级向上委托（App-->ext-->boot,此时不会搜索该类是否存在），boot没有父类，此时boot会查找它的包含范围中是否有该class，如果有就加载，如果没有找ext，ext会查找它的包含范围中是否有该class，如果有就加载，如果没有找app，查找它的包含范围中是否有该class，如果有就加载，如果没有抛出异常，ClassNotFoundException。

Hello.class文件要加载，先逐级委托，委托到boot，搜索boot中是否有hello，如果有就加载，没有去找ext中否是有，有就加载，没有找app，如果有加载，没有抛异常。

2.反射技术

步骤：

\1. 获取Class对象，该Class对象代表这个一个class文件

\2. 获取Class的对象表示的class文件中的内容，并对这些内容进行想要的操作。

反射技术的源头：Class对象。

1.获取Class对象：

1.已有对象的情况下： getClass()

Class c1 = p1.getClass();

2.已知类型名的情况下： 类型名.class

Class c2 = Person.class;

3.已知全类名的情况下： Class.forName(“包名.类名”)

Class c3 = Class.forName("Person");

2.构造方法：

1.获取构造方法

  1. getConstructors() 获取所有公共的构造方法，返回一个Constructor数组

Constructor[] cons = c1.getConstructors();

2.getDeclaredConstructors() 获取所有权限的构造方法，返回一个Constructor数组

Constructor[] cons1 = c1.getDeclaredConstructors()

3. getConstructor(String.class,int.class) 已知参数 获取单个公共构造方法

Constructor c1 = c.getConstructor();

4.getDeclaredConstructor(String.class,int.class) 已知参数获取单个构造方法

Constructor c2 = c.getDeclaredConstructor(String.class,int.class)

2.根据构造方法创建实例对象

T newInstance(); 根据指定的构造方法创建对象

基本数据类型也是可以通过 .calss 得到相应的Class类型

1.直接通过Class对象创建实例对象

Person p1 = c1.newInstance();           //前提是这个类有构造方法

2.通过得到的构造方法对象创建实例对象

Constructor con1 = c1.getConstructor();
Person p2 = con1.newInstance();

3.根据有参构造方法创建实例对象，如果方法是private修饰过的属性，需要使用暴力反射

//  c2.setAccessible(true)      参数为true代表取消访问检查，可以操作私有成员
Constructor c2 = c.getDeclaredConstructor(String.class,int.class)
Person p3 = c2.newInstance("小明", 20)

3.File字段

1.获取字段

1. getFields() 获取所有公共属性，包括父类的，返回一个Field数组

Field[]  f1 = c.getFields();

2. getDeclaredFields() 获取所有当前类的属性，返回一个Field数组

Field[]  f2 = c.getDeclaredFields();

3. getField(String name) 获取单个公共属性

Field ff1 = c.getField("b");

4. getDeclaredField(String name) 获取单个属性，忽略权限修饰

Field ff2 = c.getDeclaredField("name");

2.使用字段赋值

  1. field . set（Object obj ，Object value） 给某个实例对象的每个属性赋值

    如果属性是private修饰过的属性，需要使用暴力反射

//创建类对象
Class<Person> c1 = Person.class;
//获取属性
Field namefield = c1.getDeclaredField("name");
//给对象的这个属性赋值
//namefield.setAccessible(true);    暴力反射
Person p = c1.newInstance();
namefield.set(p,"小黑");

4.成员方法

1.获取成员方法

  1. getMethods() 返回所有公共的成员方法，包括继承的，返回一个method数组

    Class c = Class.forName("Person");
Method[] me1 = c.getMethods();

    1. getDeclaredMethods() 返回本类中的所有成员方法，返回一个method数组

     Method[] me2 = c.getDeclaredMethods();

  2. getMethod("setName", String.class) 已知方法名和参数返回单个公共成员方法

Method m1 = c.getMethod("setName", String.class);

  1. getDeclaredMethod("show") 根据参数返回单个成员方法,忽略权限修饰符

 Method m3 = c.getDeclaredMethod("show");

2.使用方法

  1. Object 方法.invoke（对象，参数） 返回Object类型

m3.invoke(p);

  1. 带返回值的方法

     String  name = (String) m2.invoke(p);

    1. 如果是private修饰过的方法，需要暴力反射

      Method m3 = c.getDeclaredMethod("show");
m3.setAccessible(true);
m3.invoke(p);
​
yuan_kk0321
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java之网络编程以及反射
weixin_41719737的博客
07-29 209
网络编程以及反射： 代码演示： public class Demo_ZhangWuJi {//1.利用TCP方式实现张无忌与李寻欢聊天 public static void main(String[] args) throws IOException { ServerSocket server = new ServerSocket(55555); Socket socket = ser...
Java学习笔记——网络编程、反射
potatobeancox55555的博客
03-25 447
十四、网络编程 1.网络编程三要素 ip、端口号、协议 2.tcp和udp UDP 面向无连接，数据不安全，速度快。不区分客户端与服务端。 TCP 面向连接（三次握手），数据安全，速度略低。分为客户端和服务端。 三次握手: 客户端先向服务端发起请求, 服务端响应请求, 传输数据 3.Socket概述 网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一...
正确的java学习顺序--刚入门的同学可以看这里
githubcurry
11-30 1万+
对于刚学习java的人来说，可能最大的问题是不知道学习方向，每天学了什么第二天就忘了，而课堂的讲解也是很片面的。今天我结合我的学习路线为大家讲解下最基础的学习路线，真心希望能帮到迷茫的小伙伴。（有很多人给你说过让你好好学习，但是没有人给你说应该怎么好好学习，这篇博客就是关于怎么好好学习的） 1. H5+css3：这个阶段是必须要度过的，这个阶段可以快速的培养起来你的编程兴趣，因为它见效快，一天就可以学到好多东西并且做出来实例。参考：菜鸟教程 2. JavaScript：html是控制页面的布局，css控制.
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础知识面试题（2020最新版）
热门推荐
ThinkWon的博客
02-19 131万+
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
Java基础知识点汇总
qq_41286666的博客
05-04 4万+
Java基础知识点汇总1. Java基础语法2. 面向对象3. 异常处理4. 集合5. IO流 1. Java基础语法 类型转换 // 强制类型转换 float a = 20.34f; int b = (int)a; //自动类型转换 int c = 10; float d = c; //操作较大的数时，注意溢出问题 //JDK7新特性，数字之间可以用下划线分割
Java基础知识面试题
学Java，找哪吒
08-24 5万+
一、JDK 和 JRE 有什么区别？ JDK（Java Development Kit），Java开发工具包 JRE（Java Runtime Environment），Java运行环境 JDK中包含JRE，JDK中有一个名为jre的目录，里面包含两个文件夹bin和lib，bin就是JVM，lib就是JVM工作所需要的类库。 二、== 和 equals 的区别是什么？ 1、对于基本类型，==比较的是值； 2、对于引用类型，==比较的是地址； 3、equals不能用于基本类型的比较； 4、如果
Java基础知识点总结
是阿超
09-25 4729
Java基础知识点总结
Java知识体系最强总结(2021版)
ThinkWon的博客
12-18 110万+
更新于2019-12-15 10:38:00 本人从事Java开发已多年，平时有记录问题解决方案和总结知识点的习惯，整理了一些有关Java的知识体系，这不是最终版，会不定期的更新。也算是记录自己在从事编程工作的成长足迹，通过博客可以促进博主与阅读者的共同进步，结交更多志同道合的朋友。特此分享给大家，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。 文章目录...
Java基础知识点总结.docx
04-03
Java是一种广泛使用的面向对象的编程语言，其基础知识涵盖了多个方面，包括语法、面向对象特性、异常处理、多线程...以上只是Java基础知识的一个概述，每个话题都值得深入探讨和实践，不断学习和总结是提升技能的关键。
java基础编程必须知道的：SPI、反射、位运算
08-09
Java基础编程涵盖了许多核心概念，其中包括SPI（Service Provider Interface）、反射和位运算。这些特性都是Java强大灵活性的关键组成部分。 SPI（Service Provider Interface）是Java的一种服务发现机制，它允许...
Java基础知识总结（超详细整理）
02-02
【Java基础知识总结】 ...总的来说，Java基础知识的学习是一个逐步深入的过程，从简单的语法到复杂的概念，每个环节都是构建强大编程技能的基础。只要你保持持续学习和实践，就能够掌握这门强大的编程语言。
java思维导图 （基础知识、多线程、网络编程反射、设计模式、常用API）
03-16
java思维导图 （基础知识、多线程、网络编程反射、设计模式、常用API） java思维导图 （基础知识、多线程、网络编程反射、设计模式、常用API） java思维导图 （基础知识、多线程、网络编程反射、设计模式、常用API）...
java语言基础知识（完整版）.zip
最新发布
11-01
Java语言基础知识是编程学习的重要部分，它为开发者提供了构建复杂应用程序的基础。这个“java语言基础知识（完整版）.zip”压缩包包含了一份详尽的PDF文档，旨在全面讲解Java编程的核心概念。以下是对这些基础知识...
路由技术基础（IP、子网掩码）
yuan_kk0321的博客
12-13 2764
一、什么是IP 百度百科官方解释： IP规定网络上所有的设备都必须有一个独一无二的IP地址，就好比是邮件上都必须注明收件人地址，邮递员才能将邮件送到。同理，每个IP信息包都必须包含有目的设备的IP地址，信息包才可以正确地送到目的地。同一设备不可以拥有多个IP地址，所有使用IP的网络设备至少有一个唯一的IP地址。 简单理解： IP是互联网中所有设备的唯一标识，就想我们的身份证号一样时独一无二的，这样就可以确保信息准确无误的送达 二、IP的分类 IP分为IPv4和IPv6 ​
JAVA基础知识七（补充知识：lambda表达式、正则表达式）
yuan_kk0321的博客
12-13 1171
十二、lambda表达式 1.接口新特性 在jdk1.8前：常量 和 抽象方法 成员都是公共的，修饰也是固定的 实现类必须实现所有的抽象方法，否则还是抽象类 在jdk1.8后：允许有带有方法体的方法。 默认方法 default修饰 静态方法 static修饰 1.默认方法： 1.实现类可以重写也可以不重写 2.实现类中可以直接调用默认方法 3.重写了默认方法，想要调用父接口中的，父接口名.super.默认方法名(). 4.实现类实现了多个接口，接口中有相同的方法定义，实现类必须重写该
JAVA基础知识一（java简介，基础语法）
yuan_kk0321的博客
07-17 456
一、 Java简介 1.Java语言简介 从1991年开始研发，Java语言之父(詹姆斯.高斯林)，Green项目小组，C++，oak(橡树)。 1995年，想要将oak语言正式对外发布，java(咖啡杯)，1996年正式发布--JDK。 公司：SUN公司，Oracle公司收购。 JDK 是一款软件，作用：用来编译和执行java语言所编写的程序。 2.发展史 \1. 1996年，jdk1.0。 jdk5.0:泛型、可变参数、枚举...。 JDK8.0: Lambda表达式/函数式接口/Str
JAVAWeb知识
yuan_kk0321的博客
12-14 361
Java基础入门教程：GUI编程详解
异常处理、网络编程、JDBC（Java数据库连接）和反射机制也是Java基础的重要组成部分，它们分别用于程序错误的捕获和处理、网络通信、数据库操作以及运行时动态访问类和方法的能力。 这份Java基础入门教程全面介绍了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值