第五周JAVA学习总结

最新推荐文章于 2024-07-10 21:37:49 发布

zhangjinyan1

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量127

点赞数

文章标签： java 学习 udp

本文链接：https://blog.csdn.net/zhangjinyan1/article/details/128161093

版权

晨写

11.28晨写

1.网络编程的三要素

Ip地址----->点分十进制法 :一般自己都是用C类:私人地址 192.168.1.5:前面三个号段网络号段,后面这个是主机号段
端口号port:不同机器之间的通信,必须绑定端口 0-65535 里面0-1024是保留端口
协议:
UDP和TCP

2.Properties属性集合列表的特有添加以及遍历方式

//属性集合列表Properties
public String setProperty(String key,String value)
public Set<String> stringPropertyNames() //获取所欲的键的集合
public String getProperty(String key)//通过键获取值

3.如何读取src下面的后缀为.properties的配置文件


//src下面是类路径
//1)获取当前类的字节码文件对象 类名.class---------->Class clazz
Class clazz = MyDemo.class;
//2)Class类--->加载了需要使用类加载器
ClassLoader cl = clazz.getClassLoader();
//3)通过类加载来获取src下面的资源文件的输入流对象
InputStream inputStream = cl.getResourceAsStream("xxx.properties") ;
//4)创建属性集合列表
Properties prop = new Properties() ;
//5)将资源文件所在的输入流对象加载到属性集合列表中
prop.load(inputStream) ;5.UDP发送端和接收端代码实现---->

4.UDP和TCP的区别

1)是否建立连接通道
Udp协议不要建立连接通道
TCP协议需要建立连接通道
2)是否安全
udp是不安全,是不可靠协议,效率高
tcp是安全,是可靠协议,效率低
3)是否发送数据大小有限制
udp是发送数据大小有限制的
TCP是发送数据无限制,相对UDP来说

5.UDP发送端和接收端代码实现---->


//发送端
//创建发送端的Socket对象
DatagramSocket ds = new DatagramSocket() ;
//创建数据报包
String content = "hello,udp我来了";
byte[] bytes = content.getBytes() ;
DatagramPacket dp = new DatagramPacket(bytes,bytes.length,InetAddress.getByName("127.0.0.1"),10086) ;
//发送数据报包
ds.send(dp) ;
//释放资源
ds.close() ;
//接收端
//创建接收端的Socket
DatagramSocket serverDs = new DatagramSocket(10086) ;
//创建接收容器,自定义的字节缓冲区
byte[] buƊ er = new byte[1024] ;
int buƊ erLength = buƊ er.length ;
Datagrampacket receiveDp = new DatagramPacket(buƊ er,buƊ erLength) ;
//接收
serverDs.receive(receiveDp);
//解析真实数据
byte[] bytes2= receiveDp.getData() ;//获取实际缓冲区中字节
int length2 = receiveDp.getLength() ;
//获取ip地址String
String ip = receiveDp.getInetAddress().getHostAddress() ;
String receiveContent = new String(bytes2,0,length2) ;
//展示ip(哪个接收端发的)和receiveContent(接收的内容)
UDP发送端可以不断键盘录入数据,接收端不断展示数据,发送可以自定义结束条件

11.29晨写

1.什么是反射?

在加载类的时候----编译后Class(类对象),它里面通过创建对象让程序之间解耦;(作用)
Reflection:反射---->是指程序可以访问,检查,它本身一种状态的行为能力,在对于任意一个对象,都能够通过获取当前类的字节码文件对象(Class).动态获取它里面的信息和访问权限---->Java的反射机制
Animal a = new Cat() ;//多态---->存在耦合了
Class clazz = Class.forName("子类的全限定名称") ;
//获取构造器Constructor类对--->如果当前无参构造公共的==直接newInstace()

2.获取一个类的字节码文件的方式

三种方式:
    方式1:任意Java对象的getClass()
    方式2:任意Java类型的class属性
    方式3:Class.forName("类或者接口的全限定名称") ;

3.TCP客户端和服务器端代码实现


//TCP客户端
Socket socket = new Socket("10.35.162.121",10086) ;
//获取客户端通道内的字节输出流
OutputStream out = socket.getOutputStream() ;
//写数据
out.write("hello,TCP".getBytes()) ;
//释放资源
socket.close() ;
//TCP服务器端
ServerSocket ss = new ServerSocket(10086) ;
//监听客户端连接
Scoket s = ss.accept() ;
//获取监听到的客户端所在通道字节输入流对象
InputStream in = s.getInputStream() ;
//一次读取一个字节数组
byte[] bytes = new byte[1024] ;
int len = in.read(bytes) ;
//展示数据
String str = new String(bytes,0,len) ;
System.out.println(str) ;
//TCP客户端
Socket socket = new Socket("10.35.162.121",10086) ;
//获取客户端通道内的字节输出流
OutputStream out = socket.getOutputStream() ;
//写数据
out.write("hello,TCP".getBytes()) ;
//释放资源
socket.close() ;
//TCP服务器端
ServerSocket ss = new ServerSocket(10086) ;
//监听客户端连接
Scoket s = ss.accept() ;
//获取监听到的客户端所在通道字节输入流对象
InputStream in = s.getInputStream() ;
//一次读取一个字节数组
byte[] bytes = new byte[1024] ;
int len = in.read(bytes) ;
//展示数据
String str = new String(bytes,0,len) ;
System.out.println(str) ;

4.通过反射获取构造器Constructor并创建对象

private 类名(String xx,int xx){....}
//获取当前类的字节码文件对象
Class clazz = Class.forName("类的全限定名称") ;
//获取指定的构造方法所在的Constrcutor类对象--->
//Constructor con = clazz.getConstructor() ;//无参构造方法 公共的
//创建当前类实例
//Object obj = con.newInstance() ;
Constructor myCon = clazz.getDeclaredConstructor(String.class,int.class) ;
//私有的构造方法-->抑制Java语言检查功能
myCon.setAccessiable(true) ;
Object obj = myCon.newInstance() ;

5.通过反射获取成员方法Method类对象并调用方法

//获取当前类的字节码文件对象
Class clazz = Class.forName("类的全限定名称") ;
//如果当前构造方法是无参的,而且是公共的
//直接使用Class--->public T newIntance() :创建当前类实例
Object obj = clazz.newInstance() ;
//通过字节码文件对象获取当前类的成员方法所在的类对象Method
Method m = clazz.getDeclaredMethod("方法名",参数类型的class属性) ;
//如果方法私有的,需要取消Java语言检查
m.setAccessiable(true) ;
//调用方法
Object returObj = m.invoke(obj,实际参数) ;//如果本身方法有返回值,则返回,如果没有返回值,不用返回

11.30晨写

1.请描述静态代理

代理设计模式属于结构型设计模式的一种!
静态代理:
代理角色和真实角色需要实现同一个接口!
回想线程中的Thread类:代理角色本身一个接口Runnable
自定义一个类实现Runnable接口,实现里面的run方法---->真实角色

2.什么是jdk动态代理 (重点)

//jdk动态代理--->前提必须有一个接口
//是通过反射的动态的产生代理实例,完成对业务功能增加
// java.lang.reũ ect.Proxy--->提供静态方法
public static Object newProxyInstance(ClassLoadr cl,Class[] interfaces,InvocationHandler handler)
package com.qf.reũ ect_03;
/**
* @author 高圆圆
* @date 2022/11/29 11:38
* 针对用户操作的数据访问接口
*/
public interface UserDao {
void add() ;
void delete() ;
void Ũ ndAll() ;
void update() ;
}
package com.qf.reũ ect_03;
/**
* @author 高圆圆
* @date 2022/11/29 11:39
* 数据接口实现
*/
public class UserDaoImpl implements UserDao{
/**
* 添加
*/@Override
public void add() {
System.out.println("添加用户");
}
/**
* 删除
*/
@Override
public void delete() {
System.out.println("删除用户");
}
/**
* 查询
*/
@Override
public void Ũ ndAll() {
System.out.println("查询所有用户");
}
/**
* 修改
*/
@Override
public void update() {
System.out.println("更新用户");
}
}

package com.qf.reũ ect_03;
import java.lang.reũ ect.InvocationHandler;
import java.lang.reũ ect.Method;
/**
* @author 高圆圆
* @date 2022/11/29 11:55
* 自定义一个类----->代理实例 调用处理程序实现的接口
*
* //就完成真实角色的里面的add(),update(),Ũ ndAll(),detete()这些方法调用并进行增强
*/
public class MyInvocationHandler implements InvocationHandler {
//目标对象--->真实角色
private Object target ;
public MyInvocationHandler(Object target){
this.target = target ;
}
/**
* 具体实现UserDao接口,调用里面的方法!完成业务方法增强
* @param proxy
* @param method 调用的方法 add(),update(),Ũ ndAll(),detete()
* @param args 这些方法实际参数
* @return 从代理实例上的方法调用返回的值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("权限校验") ;
//反射调用
Object obj = method.invoke(target, args);
System.out.println("产生日志");
return obj;
}
}
/**
public static Object newProxyInstance(
* ClassLoader loader, //参数1:当前接口对象的类加载器
* Class<?>[] interfaces, //参数2:代理实现接口列表字节码文件对象的数组
* InvocationHandler h //参数3:代理实例 调用处理程序实现的接口
* ) throws IllegalArgumentException
*/
UserDao ud = new UserDaoImpl() ;
InvocationHandler handler = new MyInvocationHandler(ud) ;
UserDao ud3 = (UserDao) Proxy.newProxyInstance(
ud.getClass().getClassLoader(),
//public Class<?>[] getInterfaces()
ud.getClass().getInterfaces(),
handler
);
ud3.add();
ud3.delete();
ud.Ũ ndAll();
ud3.update();

3.如何使用反射获取类的成员变量Field并去赋值

//获取当前类的字节码文件对象
Class clazz = Class.forName("包名.类名") ;
//创建当前类实例---如果当前类的无参构造方法是公共的
Object obj = clazz.newIntance() ;
//通过字节码文件对象获取指定的成员变量所在的Field类对象
Field field = clazz.getDeclaredField("属性名称") ;
//如果私有肯定需要取消Java语言访问检查
field.setAccessiable(true) ;
//赋值
field.set(obj,实际参数) ;
System.out.println(obj) ;

4.如何使用反射获取类的成员方法Method并去调用

//获取当前类的字节码文件对象
Class clazz = Class.forName("包名.类名") ;
//创建当前类实例---如果当前类的无参构造方法是公共的
Object obj = clazz.newIntance() ;
//通过字节码文件对象获取指定的成员方法 所在的Method类对象
Method method = clazz.getDelcaredMethod("方法名名称",参数类型的class属性) ;
//如果私有肯定需要取消Java语言访问检查
method.setAccessiable(true) ;
//调用
method.invoke(obj,实际参数) ; //有返回值,直接返回;没有,可以的直接调用即可

12.1晨写

1.DDL语句建库 ,查询库的信息,删除库,修改库的字符集

-- 创建库
create database if not exists 库名;
create database 库名;
-- 查询库的信息
show create database 库名;
-- 删除库
drop database  if exists 库名 ;
drop database 库名;
-- 修改的字符集
alter database 库名 default character set 字符集格式;

2.DDL语句建表,修改库中的字段名称以及字段类型,删除表

-- 创建表
create table 表名(
    字段名称1 字段类型1,
    字段名称2 字段类型2,
    ...
    字段名称n 字段类型n
) ;
-- 修改表的字段名称
alter table 表名 change 旧字段名称 新字段名称 以前的数据类型;
-- 修改表的字段类型
alter table 表名 modify 字段名称 新的数据类型;
-- 删除
drop table if exists 表名;
drop table 表名;
-- 查询表结构
desc 表名;

3.DML语句: 插入数据,修改数据,删除数据

-- 插入数据
-- 插入全表,一次插入多条
insert into 表名 values(值1,值2,....值n),(值1,值2,....值n),...() ;
-- 插入部分字段,一次插入多条
insert into 表名(字段名称1,字段名称2,部分字段....) values(值1,值2,部分值),(值1,值2,部分值...),();

-- 修改数据---按照条件修改
update 表名 set 字段名称1 =值1,字段名称2 = 值2 where 字段名称 = 值;
-- 删除:按照条件删除
delete from 表名 where 字段名称 = 值;

4.delete from 表名和truncate table 表名的区别?

前者:仅仅是删除全表数据
表的结构还在,如果表中主键自增长的字段,不会影响这个自增主键的值,下一次插入数据,依然在上一次删除的最后一个自增长主键的值继续自增;
后者:删除表的全部数据,同时删除了表,然后创建一张空表
直接影响了自增长主键的值,下一次插入数据,从1开始继续自增

5.查询指定字段并指定别名

select
   字段名称1 as 别名名称1,
   字段名称2 as 别名名词2,
   ...
from
   表名;

12.2晨写

1.DQL语句之分页查询

select 字段列表 from 表名 where 条件.... limit 起始行数,每页显示的条数

-- 起始行数=(当前页码数-1)*每页显示的条数

2.DQL语句之模糊查询和和排序查询语法

select 字段列表 from 表名 where 字段名称 like '%值%';
-- 排序查询
select 字段列表 from表名 order by 字段名称排序规则 ;

3.关于group by和having的区别

having:在满足where以及group by之后查询的结果集中,进行过滤(帅选)声明;having后面可以使用聚合函数
group by 后面使用分组字段或者表达式--->后面不能使用聚合函数,where必须放在group by之前

where...group by...having...

4.什么单例设计模式?

/*单例设计模式:
    在内存中始终只有当前类的一个实例!(只有一个对象)
    饿汉式和懒汉式
    饿汉式:不会出现问题的单例设计模式
    
    1)构造方法私有化
    2)类一加载,成员位置---私有的静态实例变量(立即创建一个对象)
    3)对外提供一个静态的公共的访问方法,返回值是当前类本身
    */
// Runtime本身就是一个饿汉式
public Student{
    private static Student s = new Student() ;
    private Student(){}
    public  static Student getStudent(){
        return s ;
    }
    
}
/*
    懒汉式 :可能出现安全问题的单例设计模式 (懒加载/延迟加载)
    一个用户有100账户,一对多的关系
    
    1)构造方法私有化
    2)在类的成员位置,声明一个静态类变量,当前类本身
    3)提供对外的公共访问方法,返回值当前类本身,需要对当前变量进行判断,如果为null,在创建
    
*/
public Student{
    private static Student s ;
    private Student(){}
    
    public  synchronized static Student getStudent(){
        if(s ==null){
            s = new Student() ;
        }
        return s ;
    }
    
}

5.什么是jdk动态代理

/*
    jdk动态代理:前提需要有接口---基于接口来完成
    java.lang.reflect.Proxy
            public Object static newProxyInstance(ClassLaoder classloader,Class[] interfaces,InvocationHandler handler)
*/
interface UserDao{
    void add() ;
    void delete();
}
class UserDaoImpl implemnets UserDao{
    public void add(){
        System.out.println("添加") ;
    }
    public void delete(){
        System.out.println("删除") ;
    }
}

//实现代理处理程序--->调用接口的方法---来完成业务功能增强
class MyInvocationHandler implements InvocationHandler{
    
    private Object target ;
    public MyInvocationHandler(Object target){
        this.target = target;
    }
    
    
    /method--->接口中调用 add delete
    public Object invoke(Object proxy,Method method,Object[] args){
        System.out.println("完成权限认证") ;
        Object obj = method.invoke(target,args) ;
        System.out.println("完成日志的输出") ;
        reutnr obj ;
        
    }
}

class MyTest{
    public static void main(String[] args){
        
        //真实角色
        UserDao ud = new UserDaoImpl() ;
        ud.add() ;
        ud.delete();
        
        
        InvocationHandler handler = new MyInvocationHandler(ud) ;
        UserDao ud2 = (UserDao)Proxy.newInstance(ud.getClass().getClassLoader(),
                         ud.getClass().getInterfaces(),handler) ;
        ud2.add();
        ud2.delete() ;
        
    }
}