day024 -- 简介

最新推荐文章于 2024-10-12 17:55:45 发布
最新推荐文章于 2024-10-12 17:55:45 发布
阅读量116 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hai_qi/article/details/126311914
版权

1.反射

1.1获取Class对象

  • 获取Class对象的三种方式

    Class.forName(“包名+ 类名”);
    类.class
    对象.getClass()
    package com.qfedu.b_class;

import com.qfedu.a_reflect.Person;

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //类权限定名
        Class<?> aClass = Class.forName("com.qfedu.a_reflect.Person");
        System.out.println(aClass);
        //获取所有的信息
        Class<Person> personClass = Person.class;
        System.out.println(personClass);
        //通过对象调getClass获得
        Class<? extends Person> aClass1 = new Person().getClass();
        System.out.println(aClass1);
    }
}

1.2获取Constructor对象

1.class对象.getConstructor();
2.construct对象.newInstance();根据构造方法实例化对象

package com.qfedu.c_conStructor;

import com.qfedu.a_reflect.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo1 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取Class对象
        Class<Person> personClass = Person.class;
        //通过getConstructors()获取对象的所有公开的构造方法
        Constructor<?>[] constructors = personClass.getConstructors();
        System.out.println(constructors);
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("==============");
        //获取一个类所有的构造方法对象
        Constructor<?>[] declaredConstructors = personClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        //获取单个constructor对象
        //获取无参的构造方法
        Constructor<Person> constructor = personClass.getConstructor(null);
        System.out.println(constructor);
        System.out.println("-----------");
        //获取有参构造的构造方法
        Constructor<Person> constructor1 = personClass.getConstructor(String.class);
        System.out.println(constructor1);
        Constructor<Person> constructor2 = personClass.getConstructor(int.class);
        System.out.println(constructor2);
        //newInstance(Object...parameter) 是constructor对象调的
        //获取无参构造方法的内容，赋默认的值null
        Person person = constructor.newInstance(null);
        System.out.println(person);
        //如果是有参的内容，先对属性进行赋值
        Person person1 = constructor1.newInstance("狗蛋");
        System.out.println(person1);
    }
}

1.3获取Method对象

1.class对象.getMethod(String name, Class<?> …parameterType);
2.method对象.invoke(Object obj, Object… initargs);

package com.qfedu.d_method;

import com.qfedu.a_reflect.Person;

import java.lang.reflect.Method;

public class Demo1 {
    public static void main(String[] args) throws NoSuchMethodException {
        Class<Person> personClass = Person.class;
        //通过class对象获取一个类下面成员方法对象Method
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("================");
        //获取本类的所有的成员方法
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        //获取单个成员方法，无法获取私有的成员方法
        Method eat = personClass.getMethod("eat", null);
        System.out.println(eat);

    }
}

1.4获取Field对象

1.getFields获取公开的属性

2.getDeclaredField();获取单个属性

3.set(对象，要被赋的值) 对对象属性进行赋值

4.setAccessible(boolean)；暴力反射，可以是对象接近私有化属性

package com.qfedu.e_field;

import com.qfedu.a_reflect.Person;

import java.lang.reflect.Field;

public class Demo1 {
    public static void main(String[] args) throws NoSuchFieldException, InstantiationException, IllegalAccessException {
        //属性是在一个类下，也要Class对象获取属性
        Class<Person> personClass = Person.class;
        //获取公开的属性
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("================");
        //获取所有的属性
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //获取单个属性,获取私有的和默认的会报错
        Field sex = personClass.getField("sex");
        System.out.println(sex);
        //获取单个属性,都可以获取
        Field name = personClass.getDeclaredField("name");
        System.out.println(name);
        //对属性进行赋值
        Person person = personClass.newInstance();
        sex.set(person,'蛋');
        System.out.println(person);
        //通过暴力反射使对象接近私有属性，从而可以对私有属性进行赋值
        name.setAccessible(true);
        name.set(person,"狗蛋");
        System.out.println(person);
    }
}

1.5反射的优缺点

优点 ：可以让代码更加灵活、为各种框架提供开箱即用的功能提供了便利
缺点 ：让我们在运行时有了分析操作类的能力，这同样也增加了安全问题。
比如可以无视泛型参数的安全检查（泛型参数的安全检查发生在编译时）。
另外，反射的性能也要稍差点，不过，对于框架来说实际是影响不大的

2.jdk1.8新特性

2.1单例模式

只允许使用一个对象

固定的语法格式

懒汉式的写法

 private static Dog dog = null;
    private Dog(){

    }
    public static synchronized Dog getInstance(){
        if (dog == null) {
            dog = new Dog();
        }
        return dog;
    }

饿汉式的写法

package com.qfedu.f_jdk;

class Cat {
    //限制了对象唯一性以及线程唯一性
    private static final Cat cat = new Cat();
    private Cat() {

    }
    public static Cat getInstance() {
        return cat;
    }
}
public class Demo4 {
    public static void main(String[] args) {
        //获取Cat对象
        //获得的对象是同一个，根据地址可知
        Cat cat = Cat.getInstance();
        System.out.println(cat);//com.qfedu.f_jdk.Cat@1b6d3586
        Cat cat1 = Cat.getInstance();
        System.out.println(cat1);//com.qfedu.f_jdk.Cat@1b6d3586
    }
}

注意：懒汉式是线程安全的

​ 饿汉式是线程不安全的

开发中使用懒汉式，因为性能比较好，节约内存

2.2序列化

类 ObjectInputStream（反序列化） 和 ObjectOutputStream（序列化） 是高层次的数据流，它们包含反序列化和序列化对象的方法。

功能：将对象的属性，方法序列化存入文件中，后缀是ser.（乱码，无法查看）序列化

并从文件中读取出这个文件。 反序列化

2.2.1案例

正序列化，将对象属性和方法存入的文件中

package com.qfedu.g_test;

import java.io.*;

class Person implements Serializable{
    String name;
    int age;
    char sex;
    public void sleep(){
        System.out.println("我喜欢睡懒觉");
    }
}
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //获取属性序列化存入的文件地址
        FileOutputStream fos = new FileOutputStream(new File("D:/aaa/732.ser"));
        //将文件地址传入到反序列化流中
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //对对象内容进行赋值
        Person person = new Person();
        person.age = 22;
        person.name = "彩云";
        person.sex = '公';
        //将对象内容序列化到文件中
        oos.writeObject(person);
        System.out.println("存入成功");
        //关闭流
        oos.close();
        fos.close();
    }
}

反序列化，在文件中读取对象的属性和方法

package com.qfedu.g_test;

import java.io.*;

public class Demo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //获取要读取内容的地址
        FileInputStream fis = new FileInputStream(new File("D:/aaa/732.ser"));
        //将内容引入到系列化输出流中
        ObjectInputStream ois = new ObjectInputStream(fis);
        //进行强转，获取Person对象
        Person o = (Person)ois.readObject();
        //读取文件中的内容
        System.out.println(o.name);
        System.out.println(o.age);
        System.out.println(o.sex);
        o.sleep();
        //关闭流
        ois.close();
        fis.close();
    }
}

2.3Lambda表达式

Lambda表达式运行函数式编程。就是简化代码的。变得更加简洁，但是可读性特别差

1.Lambda表达式可以用来简化匿名内部类的书写

2.Lambda表达式只能简化函数式接口的匿名内部类的写法

3.函数式接口只有一个抽象方法

package com.qfedu.h_lambda;

import java.util.Arrays;
import java.util.Comparator;

public class Demo1 {
    public static void main(String[] args) {
        Integer[] arr= {6,2,4,9,3,1,10};
        //lambda简化匿名内部类
        Arrays.sort(arr, (Integer o1, Integer o2) -> {
                return o1 - o2;
            }
        );
        //对lambda简化
        //一行代码搞定
        Arrays.sort(arr,((o1, o2) -> o1 - o2));
        //已经拍好序
        //正常匿名内部类写法
//        Arrays.sort(arr, new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//
//                return o1 - o2;
//            }
//        });
        System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 6, 9, 10]
    }
}

1.参数类型可以省略不写

2.如果只有一个参数，参数类型可以省略，同时（）也可以省略。

3.如果Lambda表达式只有一行，大括号，分号，return可以省略不写，但需要进行同时省略

package com.qfedu.h_lambda;

public class Demo2 {
    public static void main(String[] args) {
        //传统写法
//        lambda(new Swim() {
//            @Override
//            public void swimming() {
//                System.out.println("正在游泳~~~~");
//            }
//        });
        //简化写法
//        lambda(()-> {
//            System.out.println("正在游泳~~~");
//        }
//        );
        //对lambda写法简化
        //参数类型可以省略不写
        //如果只有一个参数，参数类型可以省略，同时（）也可以省略。
        //如果Lambda表达式只有一行，大括号，分号，return可以省略不写，但需要进行同时省略
        lambda(() -> System.out.println("正在游泳"));
    }
    public static void lambda(Swim swim){
        swim.swimming();
    }
}
interface Swim{
    void swimming();


package com.qfedu.h_lambda;

import java.util.Arrays;
import java.util.Comparator;

public class Demo3 {
    public static void main(String[] args) {
        String[] arr = {"aaa", "aaaa", "aa", "a","aaaaa"};
        //匿名内部类写法
//        Arrays.sort(arr, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return  o1.length() - o2.length();
//            }
//        });
        //lambda写法
//        Arrays.sort(arr,(String o1, String o2) ->{
//                return  o1.length() - o2.length();
//            }
//        );
        //lambda简化写法
        Arrays.sort(arr,( o1,  o2) ->
              o1.length() - o2.length()

       );
        System.out.println(Arrays.toString(arr));//[a, aa, aaa, aaaa, aaaaa]

    }
}
2.3.1语法格式

接口 接口对象 = ()->表达式; 无参 无返回值的
接口 接口对象 = (parameter)->表达式; 有参 无返回值的
接口 接口对象 = ()->{表达式;}; 无参 有返回值的
接口 接口对象 = (parameter)->{表达式;}; 有参有返回值

hai_qi
关注
动手学深度学习实现DAY-2
weixin_40054643的博客
02-19 1811
节选自“ElitesAI·动手学深度学习PyTorch版” Task03：过拟合、欠拟合及其解决方案；梯度消失、梯度爆炸；循环神经网络进阶（1天） Task04：机器翻译及相关技术；注意力机制与Seq2seq模型；Transformer（1天） Task05：卷积神经网络基础；leNet；卷积神经网络进阶（1天） 过拟合、欠拟合及其解决方案 过拟合、欠拟合的概念 权重衰减 丢弃法 模型选择...
Day01_JavaSE篇
weixin_45014721的博客
08-24 422
一个程序中可以有多个类，但只能有一个类是主类。在Java应用程序中，这个主类是指包含main()方法的类。而在Java小程序中，这个主类是一个继承自系统类JApplet或Applet的子类。应用程序的主类不一定要求是public类，但小程序的主类要求必须是public类。主类是Java程序执行的入口点。定义：用于解释说明程序的文字Java注释的作用：在程序中，尤其是复杂的程序中，适当地加入注释可以增加程序的可读性，有利于程序的修改、调试和交流。
Python学习 Day 024 - 正则表达式
weixin_30553777的博客
10-10 169
主要内容: 1. 正则表达式 2. re模块 1.正则表达式 正则表达式是对字符串操作的一种逻辑公式. 我们一般使用正则表达式对字符串串进行匹配和过滤,使用正则的优缺点: 优点: 灵活, 功能性强, 逻辑性强. 缺点: 上手难,旦上手, 会爱上这个东西 工具: 各大文本编辑器一般都有正则匹...
Day1 - Hive基础知识
m0_73450879的博客
03-31 1509
hive对数据库数据表的基本命令、内外部表、静态动态分桶
Day21 - Geolocation 中文指南
孔壹学院
08-14 562
Day21 - Geolocation 中文指南 本文出自：春哥个人博客：http://www.liyuechun.org 作者：©黎跃春-追时间的人 简介：JavaScript30 是 Wes Bos 推出的一个 30 天挑战。项目免费提供了 30 个视频教程、30 个挑战的起始文档和 30 个挑战解决方案源代码。目的是帮助人们用纯 JavaScript 来写东西，不借助框架和库，
Day 024_Spring
sssurprise的博客
08-06 191
Spring 1. 简介 Spring：春天，给软件行业带来的春天 2002年，Rod Johnson首次推出了Spring框架的雏形：interface21框架 2004.3.24发布Spring框架 Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架 SSH：Struct2 + Spring + Hibernate SSM：SpringMvc + Spring + Mybatis 官网：https://spring.io/projects/spring-fram
PT-TABLE-CHECKSUM man手册
一条大河
03-09 1382
PT-TABLE-CHECKSUM /*是man pt-table-checksum的时候全文翻译*/NAME:         pt-table-checksum -       验证mysql复制完整性 SYNOPSIS简介：         使用：    pt-table-checksum [OPTIONS] [DSN]          pt—table-checksum执行一个在线复制的...
Kali Linux渗透测试 074 扫描工具-Skipfish
kevinhanser
03-05 3639
>本文记录 Kali Linux 2018.1 学习使用和渗透测试的详细过程，教程为安全牛课堂里的《Kali Linux 渗透测试》课程 > >1. Skipfish 简介 >2. Skipfish 基本操作 >3. 身份认证 >4. 提交用户名密码表单
TPC-H 使用
leixingbang的专栏
04-07 2万+
本教程主要帮助读者完成以下目标： （1）了解TPC-H的由来与简介 （2）给出dbgen Qgen的使用教程，并在windows操作系统、sqlserver2005数据库环境下生成指定规模大小的数据集，利用脚本导入数据库，建立好表的各种关联关系。 （3）给出TPC-H的中文文档翻译以及各种优秀论文推荐链接。
Linux-系统管理
记录所思、所学、所感，分享每一份收获。
03-17 5079
本章主要讲解linux系统管理的基础篇，分为进程管理、工作管理、资源查看、定时任务四个小节，其中会介绍经常用到的一些命令及其使用技巧。
linux常用命令-part3
热门推荐
chinayuan的专栏
05-01 2万+
中文怎么发音 Ubuntu 有奔头，乌版图 Fedora 费德勒，菲朵拉 Debian 迪扁，德槟 CentOS 桑托斯 森头斯       Linux发展历史: 1) RedHat ---> 1.RedHat                2.CentOS                3.Fedora  桌面图形系统        rpm, yum 命令 2)
linux常用命令-part2
chinayuan的专栏
05-01 2万+
Ubuntu,Fedora,Debian,CentOS中文怎么发音 有奔头， 费德勒， 迪扁， 桑托斯。 乌版图 菲朵拉 德槟 森头斯 ================================ 使用find和wc命令统计代码行数 ================================ wc -l `find . -name "*.js" | xargs`
JavaSE进阶基础这一篇就够了，你值得拥有！
f5465245的博客
12-01 574
本Java视频教程适合有一定编程语言基础的学员观看，在本Java视频教程中讲解了Java开发环境搭建、Java基础语法、面向对象、异常、数组、常用类、集合、IO流、线程、反射机制。该Java视频教程为讲师上课实录，共60个课时（1小时为1个课时），讲师语言表达流利，思路清晰。如果您是有一门编程语言基础的，或者您现在是一名Java程序员且想巩固一下JavaSE的，请打开Java视频教程观看吧！...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1441
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 912
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 654
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JavaSE——认识异常
最新发布
wx2023_10_15的博客
10-12 940
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
springboot 用request.setAttribute 传值到控制层
qq56477643的博客
10-09 597
【代码】springboot 用request.setAttribute 传值到控制层。
【网络编程】掌握Java网络编程：深入理解Socket通信与实战技巧
Dylaniou的博客
10-11 1042
Java的网络Socket编程为开发者提供了强大的工具来构建网络通信应用，从简单的客户端-服务器模型到复杂的分布式系统。Java的网络Socket编程为开发者提供了强大的工具来构建网络通信应用，从简单的客户端-服务器模型到复杂的分布式系统。希望本文能帮助您掌握Java网络编程的核心技术，并在实际项目中灵活运用。如果您有任何疑问或想要分享经验，请在评论区留下您宝贵的意见！🚀🌐🔌。
day--和--day区别
04-18
"day--"和"day"是两种不同的操作符，它们在编程中有着不同的含义和用法。 1. "day--"是一个后缀自减操作符，用于将变量的值减1，并返回减1之前的值。例如，如果有一个变量day的值为5，执行day--操作后，day的值将变为4，并且表达式的结果为5。这个操作符通常用于循环或迭代中，用于递减计数器或索引。 2. "day"是一个变量名或标识符，用于表示一个存储数据的位置。它可以是任何合法的变量名，用于存储某个特定类型的数据。例如，可以定义一个变量day来表示一周中的某一天。 总结起来，"day--"是一个操作符，用于递减变量的值；而"day"是一个变量名，用于表示存储数据的位置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值