devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA小白学习日记Day11

作者：一键难忘520 | 2024-07-31 06:00:57

赞

踩

JAVA小白学习日记Day11

反射

1. 反射
反射是指在运行时检查、获取和修改类的属性、方法、构造方法等信息的能力，可以在运行时动态地创建对象、调用方法、访问属性，而不需要在编译时确定。

2. 获取类对象的三种方式
在代码中展示了三种获取类对象（Class对象）的方法：

通过类名获取类对象：
Class clazz = EasyClassA.class;这种方式直接使用类名后跟 .class 来获取对应的 Class 对象。

通过对象获取类对象：
clazz = new EasyClassA().getClass();通过创建类的实例，然后调用 getClass() 方法来获取其对应的 Class 对象。

通过 Class.forName() 方法获取：
clazz = Class.forName("com.easy725.EasyColor");使用类的全限定名（包括包名）作为参数，调用 Class.forName() 方法来动态获取该类的 Class 对象。

3. Class 类对象的作用
Class 类对象包含了与类相关的信息，如属性、方法、构造方法等的定义。Class类的对象是不能new的。反射的核心是Class类，程序中使用的类，每一个都有一个唯一对应的Class对象。
在运行时，Java 使用 Class 对象来表示和管理类的结构和元数据，允许在运行时检查和操作类。

  1. package com.easy726;
  2.  
  3. public class EasyClassA {
  4.     //反射
  5.     //有对象之前必须先有类，static来修饰类的属性和方法。
  6.     //在java中存储了类的内容，这个内容也应该是一个对象。
  7.     //java中每一个类都有一个内存，这每一块内存都是一个对象。
  8.     //这些对象用来记录类中声明了哪些属性和方法以及构造方法。
  9.     //java将这些类抽象为一个Class类。
  10.     public static void main(String[] args) throws ClassNotFoundException {
  11.         //Class类的对象是不能new的
  12.         //获取类的类对象
  13.         //1.通过类名获取类对象
  14.         Class clazz=EasyClassA.class;
  15.         //2.通过对象获取类对象
  16.         clazz=new EasyClassA().getClass();
  17.         //3.通过Class方法的forName方法获取
  18.         clazz=Class.forName("com.easy725.EasyColor");
  19.         System.out.println(clazz);
  20.         //类的类对象中存储了类中定义的内容，属性/方法/构造方法。
  21.  
  22.     }
  23. }

获取和设置属性值：Field
getField("name") 可以获取 Easy 类中名为 name 的公共属性，并且可以通过 fName.get(easy) 获取 easy 对象的 name 属性的值。
getDeclaredField("code") 可以获取 Easy 类中名为 code 的任意访问控制修饰符的属性（包括私有属性），但是在访问私有属性前需要调用 setAccessible(true) 设置访问权限。
注意事项：

getField 和 getFields 只能获取公共的字段（即使用 public 修饰的字段），而 getDeclaredField 和 getDeclaredFields 则可以获取类中声明的所有字段，不论其访问控制符是什么。对于私有字段，必须通过 setAccessible(true) 来解除访问限制。

  1. package com.easy726;
  2.  
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5.  
  6. public class EasyClassB {
  7.     public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
  8.         //类的类对象中存储了类中定义的内容（属性/方法/构造方法）。
  9.         Class c=Easy.class;
  10.         c=new Easy().getClass();
  11.         c=Class.forName("com.easy726.Easy");
  12.         //获取内容
  13.         //1.获取类中的属性
  14.         //java中用来记录类的属性的类叫做Filed。
  15.         //fName指向的对象就是Easy类中的name属性。
  16.         Field fName=c.getField("name");
  17.         Easy easy=new Easy();
  18.         easy.name="张三";
  19.         System.out.println(easy.name);
  20.         //可以获取某一个Easy类的对象的name属性的值
  21.         Object objectName=fName.get(easy);
  22.         System.out.println(objectName+"---");
  23.         //注入该属性的值
  24.         fName.set(easy,"李四");
  25.         System.out.println(easy.name);
  26.         //getField和getFields只能获取类中的public声明的属性
  27.         Field fCode=c.getDeclaredField("code");
  28.         fCode.set(easy,"10001");//设置code属性的值
  29.         Object objCode=fCode.get(easy);//通过反射获取easy对象的code属性的值
  30.         System.out.println(objCode);
  31.         Field fSex=c.getDeclaredField("sex");
  32.         Field fAddress=c.getDeclaredField("address");
  33.         fSex.set(easy,"女");
  34.         //反射访问私有属性，必须先获取访问权限。
  35.         fAddress.setAccessible(true);
  36.         fAddress.set(easy,"青岛");
  37.         System.out.println(fAddress.get(easy));
  38.  
  39.         //getFields()
  40.  
  41.     }
  42. }

getInstance 方法：

getInstance 方法利用反射创建一个指定类的对象，并根据传入的 values 参数设置对象的属性值。
Class.newInstance() 方法通过调用目标类的无参构造方法来实例化对象。
设置属性访问权限：
破坏类的封装性：

反射可以访问和修改类中私有的字段，这可能会破坏类的封装性，因为它允许绕过类的设计意图直接访问私有数据成员。

  1. package com.easy726;
  2.  
  3. import java.lang.reflect.Array;
  4. import java.lang.reflect.Field;
  5. import java.util.Arrays;
  6. import java.util.HashMap;
  7. import java.util.Map;
  8.  
  9. public class EasyClassC {
  10.     //反射：在程序运行期间，可以动态获取类中定义的属性和方法以及构造方法的机制（思想）的实现
  11.     //反射的核心是Class类，程序中使用的类，每一个都有一个唯一对应的Class对象
  12.     //反射的API：Field，Method，Constructor
  13.     //反射会破坏类的封装性，通过场景说明
  14.     public static <T> T getInstance(Class<T> tClass, Map values) throws IllegalAccessException, InstantiationException {
  15.         //通过反射来获取实例，创建对象
  16.         T t=tClass.newInstance();//通过类中的无参构造方法，创建对象。
  17.         //通过反射获取类中定义的属性
  18.         Field[] farr=tClass.getDeclaredFields();
  19.         //System.out.println(Arrays.toString(farr));
  20.         for (Field fitem:farr){
  21.             //获取属性的名字
  22.             String fname=fitem.getName();//获取属性的名字
  23.             //获取该属性在Map中的键值对(属性对应的值)
  24.             Object value=values.get(fname);
  25.             //设置属性访问权限
  26.             fitem.setAccessible(true);
  27.             fitem.set(t,value);
  28.         }
  29.         return t;
  30.     }
  31.  
  32.     public static void main(String[] args) throws InstantiationException, IllegalAccessException {
  33.         Map map=new HashMap<>();
  34.         map.put("code","C10001");
  35.         map.put("name","张三");
  36.         map.put("esx","女");
  37.         Student stu=getInstance(Student.class,map);
  38.         System.out.println(stu);
  39.     }
  40. }
  41. class Student{
  42.     private String code;
  43.     private String name;
  44.     private String sex;
  45.  
  46.     @Override
  47.     public String toString() {
  48.         return "Student{" +
  49.                 "code='" + code + '\'' +
  50.                 ", name='" + name + '\'' +
  51.                 ", sex='" + sex + '\'' +
  52.                 '}';
  53.     }
  54. }

获取方法对象：Method

Method ma = c.getMethod("methodA"); 使用 getMethod() 方法获取了 Easy 类中的名为"methodA" 的公共方法对象 ma。这里 "methodA" 是方法的名称，没有参数。
调用方法：

ma.invoke(easy); 通过 invoke() 方法调用了 easy 对象的 methodA() 方法。invoke() 方法允许在运行时动态地调用方法，即使不知道方法的具体名称和参数。
获取带参数的方法：

Method mb = c.getMethod("methodB", int.class, int.class); 使用 getMethod() 方法获取了 Easy 类中的名为 "methodB"，且接受两个 int 类型参数的方法对象 mb。
调用带参数的方法：

mb.invoke(easy, 23, 45); 通过 invoke() 方法调用了 easy 对象的 methodB(int a, int b) 方法，传入了参数 23 和 45。这里的 mb 是 Method 对象，它可以动态调用 easy 对象的方法并传递参数。

  1. package com.easy726;
  2.  
  3. import java.lang.reflect.InvocationTargetException;
  4. import java.lang.reflect.Method;
  5.  
  6. public class EasyClassD {
  7.     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
  8.         //获取类对象
  9.         Class<Easy> c=Easy.class;
  10.         //反射获取方法 Method
  11.         Easy easy=c.newInstance();
  12.         //获取public方法
  13.         Method ma=c.getMethod("methodA");
  14.         //调用方法
  15.         //对象.方法名（）   面向对象
  16.         //method.invoke（对象）    反射的写法
  17.         ma.invoke(easy);
  18.         Method mb=c.getMethod("methodB", int.class, int.class);
  19.         mb.invoke(easy,23,45);
  20.  
  21.     }
  22. }

获取构造方法：Constructor

Class<Easy> c = Easy.class;Constructor<Easy> con = c.getConstructor(String.class);
通过 Class 对象获取类的构造方法，然后利用构造方法对象创建类的实例。

实例化对象：
con.newInstance("张三");使用获取到的构造方法对象调用 newInstance 方法来创建类的实例。

修饰符：使用Modifier的方法判断方法/属性/构造方法的修饰符。

获取属性的修饰符：
Field f = c.getDeclaredField("test");int fmod = f.getModifiers();
Boolean bool = Modifier.isStatic(fmod);
通过 Field 对象获取属性的修饰符，然后使用 Modifier.isStatic 方法判断属性是否为静态。
内省：
内省是一种通过反射来获取类的属性、方法等信息，但不会破坏类的封装性，主要用于获取和设置属性的读写方法。

获取属性的读写方法：
使用 Introspector.getBeanInfo 方法获取类的 BeanInfo，然后通过 PropertyDescriptor 获取属性的读写方法。

调用属性的setter方法：
Easy easy = c.newInstance();write.invoke(easy, "zhangsan");
使用反射调用 setter 方法设置属性的值。

  1. package com.easy726;
  2.  
  3. import java.beans.BeanInfo;
  4. import java.beans.IntrospectionException;
  5. import java.beans.Introspector;
  6. import java.beans.PropertyDescriptor;
  7. import java.lang.reflect.*;
  8. import java.util.Arrays;
  9.  
  10. public class EasyClassE {
  11.     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException, IntrospectionException {
  12.         //反射获取构造方法
  13.         Class<Easy> c=Easy.class;
  14.         c.newInstance();//调用无参构造方法
  15.         Constructor<Easy> con=c.getConstructor();//获取无参构造方法
  16.         con.newInstance();
  17.         con=c.getConstructor(String.class);
  18.         con.newInstance("张三");
  19.  
  20.         //修饰符，使用Modifier的方法判断方法/属性/构造方法的修饰符
  21.         Field f=c.getDeclaredField("test");
  22.         int fmod=f.getModifiers();
  23.         Boolean bool=Modifier.isStatic(fmod);
  24.         System.out.println(bool);
  25.  
  26.         //内省，也是通过反射来实现的，但是内省不会破坏封装性。
  27.         //内省获取属性的读方法和写方法来获取和设置属性的内容，不会破坏类的封装性。
  28.         //获取BeanInfo
  29.         BeanInfo bi=Introspector.getBeanInfo(c);
  30.         //获取属性的写的方法和读的方法（setter和getter）
  31.         PropertyDescriptor[] pds=bi.getPropertyDescriptors();
  32.         System.out.println(Arrays.toString(pds));
  33.         String pName=pds[0].getName();//获取属性名字
  34.         System.out.println("属性名是："+pName);
  35.         Method read=pds[0].getReadMethod();//对应属性的getter方法
  36.         Method write=pds[0].getWriteMethod();//对应属性的setter方法
  37.         //obj.setName("zhangsan");//面向对象
  38.         //write.invoke(obj,"zhangsan");//反射
  39.         Easy easy=c.newInstance();
  40.         write.invoke(easy,"zhangsan");
  41.  
  42.     }
  43. }

html常用标签   简单的css样式

文档类型声明
<!DOCTYPE html>定义了HTML文档类型，告诉浏览器这是一个HTML5文档。
HTML结构
<html>: HTML文档的根元素。
<head>: 包含了文档的元数据，如字符编码声明、标题和样式表。
<meta charset="utf-8">: 声明文档使用UTF-8字符编码，确保中文等非ASCII字符能正常显示。
<title>: 定义文档标题，显示在浏览器的标签页标题栏中。
<style>: 内部样式表，定义了表格和表格单元格的样式。
标题和段落
<h1>, <h2>: 定义标题，1级和2级标题。
<p>: 定义段落，包含文本内容。
图片和超链接
<img>: 插入图片，src属性指定图片路径，alt属性定义图片加载失败时的替代文本。
<a>: 创建超链接，href属性指定链接目标。
表格
<table>: 创建表格。
<tr>: 表格行。
<td>: 表格数据单元格。
colspan（合并列）和rowspan（合并行）: 合并单元格。
列表
<ol>: 有序列表。
<ul>: 无序列表。
<li>: 列表项。

  1. <!DOCTYPE html>
  2. <html>
  3. 	<head>
  4. 		<meta charset="utf-8">
  5. 		<title>页面标题</title>
  6. 		<style>
  7. 			table,td{
  8. 				border:1px solid deeppink;
  9. 				border-collapse: collapse;
  10. 			}
  11. 			td{
  12. 				width: 70px;
  13. 				text-align: center;
  14. 				padding: 10px;
  15. 			}
  16. 		</style>
  17. 	</head>
  18. 	<body>
  19. 		<!--标题  h1-h6 -->
  20. 		<h1>凉州词</h1>
  21. 		<h2>凉州词</h2>
  22. 		<!--段落-->
  23. 		<p>葡萄美酒夜光杯，欲饮琵琶马上催。</p>
  24. 		<!--图片-->
  25. 		<!-- .代表当前路径   ..代表上一级路径-->
  26. 		<img src="./image/easyimg.png" alt="加载失败" />
  27. 		<!-- 超链接-->
  28. 		<a href="https://www.baidu.com">链接到百度</a>
  29. 		<a href="easy.html">
  30. 			<img src="./image/easyimg.png" alt="加载失败" />
  31. 		</a>
  32. 		
  33. 		<table>
  34. 			<tr>
  35. 				<td>编号</td>
  36. 				<td>姓名</td>
  37. 				<td>成绩</td>
  38. 			</tr>
  39. 			<tr>
  40. 				<td>1001</td>
  41. 				<td>张三</td>
  42. 				<td>100</td>
  43. 			</tr>
  44. 		</table>
  45. 		<table>
  46. 			<tr>
  47. 				<td>1-1</td>
  48. 				<td colspan="2">1-2</td>
  49. 				<!-- <td>1-3</td> -->
  50. 				<td>1-4</td>
  51. 			</tr>
  52. 			<tr>
  53. 				<td rowspan="2">2-1</td>
  54. 				<td>2-2</td>
  55. 				<td>2-3</td>
  56. 				<td>2-4</td>
  57. 			</tr>
  58. 			<tr>
  59. 				<!-- <td>3-1</td> -->
  60. 				<td>3-2</td>
  61. 				<td rowspan="2" colspan="2">3-3</td>
  62. 				<!-- <td>3-4</td> -->
  63. 			</tr>
  64. 			<tr>
  65. 				<td>4-1</td>
  66. 				<td>4-2</td>
  67. 				<!-- <td>4-3</td>
  68. 				<td>4-4</td> -->
  69. 			</tr>
  70. 		</table>
  71. 		<!-- 列表 -->
  72. 		<!-- 有序列表(ol)和无序列表(ul)（有无序号） -->
  73. 		<ol>
  74. 			<li>苹果</li>
  75. 			<li>香蕉</li>
  76. 			<li>橘子</li>
  77. 		</ol>
  78. 		<ul>
  79. 			<li>苹果</li>
  80. 			<li>香蕉</li>
  81. 			<li>橘子</li>
  82. 		</ul>
  83. 	</body>
  84. </html>

表单基础：

<form> 标签定义了一个表单，用于收集用户输入的数据，action 属性指定了表单提交的地址，method 属性指定了提交方式，可以是 get 或 post。
文本输入框：

<input type="text" name="username"/> 定义了一个文本输入框，用于用户输入用户名。
密码输入框：

<input type="password" name="userpassword"/> 定义了一个密码输入框，输入的内容会被隐藏显示。
隐藏域：

<input type="hidden" value="10001" name="id"/> 定义了一个隐藏域，用于存储不希望用户看到或修改的数据，如记录用户ID等。
只读文本框：

<input type="text" readonly value="202111050441" name="code"/> 定义了一个只读文本框，用户不能编辑其内容，仅用于显示。
单选框：

<input type="radio" value="Man" name="sex" id="sexman"/><label for="sexman">男</label> 定义了两个单选框，分别用于选择性别，通过 name 属性实现单选的互斥选择。
复选框：

<input type="checkbox" name="hobby" id="sing" value="sing"/><label for="sing">唱</label> 定义了多个复选框，用户可以选择一个或多个选项，通过 name 属性实现多选。
下拉框：

<select name="province" id="province"> 定义了一个下拉框，用户可以从预定义的选项中选择一个省份。
文本域：

<textarea name="description" id="description" cols="30" rows="10"></textarea> 定义了一个多行文本输入框，用户可以输入多行文本。
按钮：

<button type="submit">提交按钮</button> 是一个提交按钮，用户点击后会提交表单数据。
<button type="button">普通按钮</button> 是一个普通的按钮，不会触发表单提交。
<button type="reset">重置按钮</button> 是一个重置按钮，点击后会将表单中的内容重置为初始状态。
普通按钮（使用 input 标签）：

<input type="button" value="普通按钮input"/> 也是一个普通的按钮，类似于上面的 <button> 元素，但使用了 <input> 标签。

  1. <!DOCTYPE html>
  2. <html>
  3. 	<head>
  4. 		<meta charset="utf-8">
  5. 		<title></title>
  6. 	</head>
  7. 	<body>
  8. 		<form action="提交表单的地址" method="提交方式get/post">
  9. 			<!-- 表单中的组件 -->
  10. 			<input type="text" name="username"/>
  11. 			<!-- 密码框 -->
  12. 			<input type="password" name="userpassword"/>
  13. 			<!-- 隐藏域 -->
  14. 			<input type="hidden" value="10001" name="id"/>
  15. 			<!-- 单选框 -->
  16. 			<!-- readonly只读 -->
  17. 			<input type="text" readonly value="202111050441" name="code"/>
  18. 			
  19. 			<!-- checked默认选中(互斥可覆盖) -->
  20. 			<div>
  21. 				<input checked type="radio" value="Man" name="sex" id="sexman"/><label for="sexman">男</label>
  22. 				<input type="radio" value="Woman" name="sex" id="sexwoman"/><label for="sexwoman">女</label>
  23. 			</div>
  24. 			<!-- 复选框 -->
  25. 			<!-- disable无法选中 -->
  26. 			<div>
  27. 				<input type="checkbox" name="hobby" id="sing" value="sing"/><label for="sing">唱</label>
  28. 				<input disabled type="checkbox" name="hobby" id="dance" value="dance"/><label for="dance">跳</label>
  29. 				<input type="checkbox" name="hobby" id="rap" value="rap"/><label for="rap">rap</label>
  30. 			</div>
  31. 			<!-- 下拉框 -->
  32. 			<!-- selected默认选中 -->
  33. 			<div>
  34. 				<label for="province">省份</label>
  35. 				<select name="province" id="province">
  36. 					<option value="sds">山东省</option>
  37. 					<option value="ahs">安徽省</option>
  38. 					<option value="xj" selected>新疆</option>
  39. 					<option value="sxs">陕西省</option>
  40. 					<option value="yns">云南省</option>
  41. 				</select>
  42. 			</div>
  43. 			<!-- 多行输入框(文本域) 两个标签中的内容就是他的值 注意不要回车-->
  44. 			<div>
  45. 				<textarea name="" id="" cols="30" rows="10"></textarea>
  46. 			</div>
  47. 			<button type="submit">提交按钮</button>
  48. 			<button type="button">普通按钮</button>
  49. 			<button type="reset">重置按钮</button>
  50. 			<input type="button" value="普通按钮input"/>
  51. 		</form>
  52. 	</body>
  53. </html>

内部样式：
CSS样式定义了几种选择器：
#boxA: ID选择器，应用于id为boxA的元素，设置了宽度、高度、背景颜色、字体颜色等样式。
div: 标签选择器，应用于所有<div>元素，设置了宽度和高度。
.bgred: 类选择器，应用于所有类名为bgred的元素，设置了背景颜色为红色并隐藏（display: none;）。
内联样式和元素：
内联样式：直接在元素上使用style属性设置样式，例如第一个<div>的样式设置了宽度、高度和背景颜色。
ID选择器应用：第二个<div>使用了ID选择器#boxA，应用了预定义的样式。
类选择器应用：后面两个<div>使用了类选择器.bgred，共享类样式，设置了背景颜色为红色并隐藏。

  1. <!DOCTYPE html>
  2. <html>
  3. 	<head>
  4. 		<meta charset="utf-8">
  5. 		<title></title>
  6. 		<style>
  7. 			/* 内部样式 */
  8. 			/* 选择器 */
  9. 			/* ID选择器 */
  10. 			#boxA{
  11. 				width: 100px;
  12. 				height: 100px;
  13. 				background-color: black;
  14. 				/* 字体颜色 */
  15. 				color: aqua;
  16. 				/* 文本大小 */
  17. 				font-size: 20px;
  18. 				text-align: center;
  19. 				/* 单行文本垂直居中 行高等于容器的高度 */
  20. 				line-height:100px;
  21. 				/* 字体加粗 */
  22. 				font-weight: bold;
  23. 			}
  24. 			/* 标签选择器（元素选择器） */
  25. 			div{
  26. 				width: 100px;
  27. 				height: 100px;
  28. 			}
  29. 			/* 类选择器  class='bgred'*/
  30. 			.bgred{
  31. 				background-color: red;
  32. 				display: none;
  33. 			}
  34. 		</style>
  35. 	</head>
  36. 	<body>
  37. 		<!-- 内联样式 -->
  38. 		<div style="width: 100px;height: 100px;background-color:peru"></div>
  39. 		<div id="boxA">Hellow</div>
  40. 		<div class="bgred"></div>
  41. 		<div class="bgred"></div>
  42. 	</body>
  43. </html>

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号