建设网站都要学些什么,北京网站建设公司怎么排版,南漳网站建设,wordpress发布页面Java面向对象
静态 static
static修饰静态成员变量
/**在线人数。注意#xff1a;static修饰的成员变量#xff1a;静态成员变量#xff0c;只在内存中有一份#xff0c;可以被共享*/
public static int onlineNumber 161;static静态成员方法
/**静态成员方法: 有stat…Java面向对象
静态 static
static修饰静态成员变量
/**在线人数。注意static修饰的成员变量静态成员变量只在内存中有一份可以被共享*/
public static int onlineNumber 161;static静态成员方法
/**静态成员方法: 有static修饰归属于类可以被共享访问用类名或者对象名都可以访问。*/
public static int getMax(int age1, int age2){return age1 age2 ? age1 : age2;
}单例模式 饿汉单例设计模式 /**使用饿汉单例实现单例类*/
public class SingleInstance {/**2、饿汉单例是在获取对象前对象已经提前准备好了一个。这个对象只能是一个所以定义静态成员变量记住。*/public static SingleInstance instance new SingleInstance();/**1、必须把构造器私有化。*/private SingleInstance(){}
}懒汉单例设计模式 /**懒汉单例*/
public class SingleInstance2 {/**2、定义一个静态的成员变量负责存储一个对象。只加载一次只有一份。注意最好私有化这样可以避免给别人挖坑*/private static SingleInstance2 instance;/**3、提供一个方法对外返回单例对象。*/public static SingleInstance2 getInstance() {if(instance null){// 第一次来拿对象 此时需要创建对象。instance new SingleInstance2();}return instance;}/**1、私有化构造器*/private SingleInstance2(){}
}final
目标记住final的语法。
1、final修饰类类不能被继承。
class Wolf extends Animal{
}final class Animal{
}2、final修饰方法方法不能被重写
public final void eat(){System.out.println(人都要吃东西~~);
}3、final修饰变量总规则变量有且仅能被赋值一次。
private final String name 猪刚鬣;常量 public static final
常量public static final 修饰的成员变量注意名称全部英文大写多个单词下划线连接。
public static final String schoolName 黑马;枚举 enum
public enum Season {// 第一行罗列枚举的实例对象的名称。SPRING,SUMMER,AUTUMN, WINTER;
}public static void move(Constant orientation){// 控制玛丽移动switch (orientation) {case UP:System.out.println(玛丽往↑飞了一下~~);break;case DOWN:System.out.println(玛丽往↓蹲了一下~~);break;case LEFT:System.out.println(玛丽往←跑了一下~~);break;case RIGHT:System.out.println(玛丽往→跑了一下~~);break;}
}抽象 abstract
/**抽象类有abstract修饰*/
public abstract class Animal {private String name;/**抽象方法有abstract修饰 不能写方法体代码*/public abstract void run();public String getName() {return name;}public void setName(String name) {this.name name;}
}模板方法模式 模板方法模式 写作文案例案例
父类声明模板方法并提供子类重写的抽象类
/*** author* create 2022-06-21 13:47*/
public abstract class Student {/*** 正式声明了模板方法模式**/public final void write(){// 标题System.out.println(\t\t\t\t《我的爸爸》);// 开头System.out.println(你的爸爸是啥样来说说);// 正文部分每个子类都要写的每个子类写的情况不一样// 因此。模板方法把正文部分定义成抽象方法交给// 具体的子类来完成System.out.println(writeMain());// 结尾System.out.println(我的爸爸简直太好了~~);}public abstract String writeMain();
}子类继承父类重写父类的抽象类
/*** author 小学生* create 2022-06-21 13:46*/
public class StudentChild extends Student{Overridepublic String writeMain() {return 的爸爸太牛b了他总是买东西给我吃。。;}}最终实现
/*** author* create 2022-06-21 13:50*/
public class Test {public static void main(String[] args) {// 目标理解模板方法模式的思想和使用步骤。StudentChild studentChild new StudentChild();studentChild.write();}
}接口 interface 接口体现了一种规范规范一定是公开的 接口的新增方法 接口
public interface SportMan {/**1、默认方法其实就是实例方法。-- 必须用default修饰默认会自带public-- 必须用接口的实现类的对象来调用*/default void run(){go();System.out.println(跑的贼溜);}/**2、静态方法-- 必须static修饰默认会自带public-- 必须用接口名自己调用*/static void inAddr(){System.out.println(我们在黑马);}/**3、私有实例方法-- 必须用private修饰-- 只能本接口中访问。-- 一般给接口中其他的默认方法或者私有实例方法使用的*/
// private void go(){
// System.out.println(开始跑~~);
// }static void go(){System.out.println(开始跑~~);}
}实现接口但是不用实现方法
public class PingPongMan implements SportMan{
}测试
public class Test {public static void main(String[] args) {// 目标理解JDK 8开始接口新增的方法。PingPongMan p new PingPongMan();p.run();SportMan.inAddr();}
}多态
多态概述和好处 创建父类动物对象
/**父类*/
public class Animal {public String name 动物名称;public void run(){System.out.println(动物可以跑~~);}
}创建子类狗对象 继承父类对象
public class Dog extends Animal{public String name 狗名称;Overridepublic void run() {System.out.println(跑的贼溜~~~~~);}
}测试
public class Test {public static void main(String[] args) {// 目标先认识多态的形式// 父类 对象名称 new 子类构造器();Animal a new Dog();a.run(); // 方法调用编译看左运行看右System.out.println(a.name); // 方法调用编译看左运行也看左动物名称}
}多态下引用数据类型的类型装换 /**目标学习多态形式下的类中转换机制。*/
public class Test {public static void main(String[] args) {// 自动类型转换Animal a new Dog();a.run();
// a.lookDoor(); // 多态下无法调用子类独有功能// 强制类型转换:可以实现调用子类独有功能的Dog d (Dog) a;d.lookDoor();// 注意多态下直接强制类型转换可能出现类型转换异常// 规定有继承或者实现关系的2个类型就可以强制类型转换运行时可能出现问题。// Tortoise t1 (Tortoise) a;// 建议强制转换前先判断变量指向对象的真实类型再强制类型转换。if(a instanceof Tortoise){Tortoise t (Tortoise) a;t.layEggs();}else if(a instanceof Dog){Dog d1 (Dog) a;d1.lookDoor();}System.out.println(---------------------);Animal a1 new Dog();go(a1);}public static void go(Animal a){System.out.println(预备~~~);a.run();// 独有功能if(a instanceof Tortoise){Tortoise t (Tortoise) a;t.layEggs();}else if(a instanceof Dog){Dog d1 (Dog) a;d1.lookDoor();}System.out.println(结束~~~~);}
}内部类 静态内部类 创建静态内部类
/**外部类*/
public class Outer {public static int a 100;private String hobby;/**学习静态成员内部类*/public static class Inner{private String name;private int age;public static String schoolName;public Inner(){}public Inner(String name, int age) {this.name name;this.age age;}public void show(){System.out.println(名称 name);System.out.println(a);// System.out.println(hobby); // 报错
// Outer o new Outer();
// System.out.println(o.hobby);}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}}
}调用静态内部类
public class Test {public static void main(String[] args) {Outer.Inner in new Outer.Inner();in.setName(张三);in.show();}
}成员内部类 创建成员内部类
/**外部类*/
public class Outer {public static int num 111;private String hobby;public Outer() {}public Outer(String hobby) {this.hobby hobby;}/**成员内部类不能加static修饰 属于外部类对象的*/public class Inner{private String name;private int age;
// public static int a 100; // JDK 16开始支持静态成员了
//
// public static void test(){
// System.out.println(a);
// }public void show(){System.out.println(名称 name);System.out.println(数量 num);System.out.println(爱好 hobby);}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}}
}调用成员内部类
public class Test {public static void main(String[] args) {Outer.Inner in new Outer().new Inner();in.setName(内部);in.show();
// Outer.Inner.test();System.out.println(------------);Outer.Inner in1 new Outer(爱听课).new Inner();in1.show();}
}案例
public class Test2 {public static void main(String[] args) {People.Heart heart new People().new Heart();heart.show();}
}class People{private int heartbeat 150;/**成员内部类*/public class Heart{private int heartbeat 110;public void show(){int heartbeat 78;System.out.println(heartbeat); // 78System.out.println(this.heartbeat); // 110System.out.println(People.this.heartbeat); // 150}}
}局部内部类 匿名内部类 匿名内部类案例
/**目标学习匿名内部类的形式和特点。*/
public class Test {public static void main(String[] args) {Animal a new Animal(){Overridepublic void run() {System.out.println(老虎跑的块~~~);}};a.run();}
}abstract class Animal{public abstract void run();
}匿名内部类的常见使用形式
/**目标掌握匿名内部类的使用形式语法*/
public class Test2 {public static void main(String[] args) {Swimming s new Swimming() {Overridepublic void swim() {System.out.println(学生快乐的自由泳);}};go(s);System.out.println(--------------);Swimming s1 new Swimming() {Overridepublic void swim() {System.out.println(老师泳的贼快~~~~~);}};go(s1);System.out.println(--------------);go(new Swimming() {Overridepublic void swim() {System.out.println(运动员的贼快啊~~~~~);}});}/**学生 老师 运动员可以一起参加游泳比赛*/public static void go(Swimming s){System.out.println(开始。。。);s.swim();System.out.println(结束。。。);}
}interface Swimming{void swim();
}重写equals
equals默认是比较2个对象的地址是否相同子类重写后会调用子类重写的来比较内容是否相同。
public class Student { //extends Object{private String name;private char sex;private int age;public Student() {}public Student(String name, char sex, int age) {this.name name;this.sex sex;this.age age;}public String getName() {return name;}public void setName(String name) {this.name name;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}public int getAge() {return age;}public void setAge(int age) {this.age age;}/**定制相等规则。两个对象的内容一样就认为是相等的s1.equals(s2)比较者s1 this被比较者 s2 o*/Overridepublic boolean equals(Object o) {// 1、判断是否是同一个对象比较如果是返回true。if (this o) return true;// 2、如果o是null返回false 如果o不是学生类型返回false ...Student ! ..Pigif (o null || this.getClass() ! o.getClass()) return false;// 3、说明o一定是学生类型而且不为nullStudent student (Student) o;return sex student.sex age student.age Objects.equals(name, student.name);}Overridepublic String toString() {return Student{ name name \ , sex sex , age age };}
}import java.util.Objects;/**目标掌握Object类中equals方法的使用。*/
public class Test2 {public static void main(String[] args) {Student s1 new Student(周雄, 男, 19);Student s2 new Student(周雄, 男, 19);// equals默认是比较2个对象的地址是否相同子类重写后会调用子类重写的来比较内容是否相同。System.out.println(s1.equals(s2));System.out.println(s1 s2);System.out.println(Objects.equals(s1, s2));}
}包装类 1、可以赋值为空
Integer age1 null;2、可以调用toString()方法得到字符串
Integer i3 23;
String rs i3.toString();
System.out.println(rs 1);3、可以把字符串类型的数值转换成真实的数据类型
String number 23;
//转换成整数
int age Integer.parseInt(number);
System.out.println(age 1);4、扩展直接使用valueOf()可以转任意类型的数值;
String number 23;
//转换成整数
int age Integer.valueOf(number);
System.out.println(age 1);Lambda表达式 /*** author* create 2022-06-22 9:55*/
public class LambdaDemo2_My {// 目标学会使用Lambda的标准格式简化匿名内部类的代码形式// 注意Lambda只能简化接口中只有一个抽象方法的匿名内部类形式函数式接口public static void main(String[] args) {// 第一种方式Pwimming pwimming new Pwimming() {Overridepublic void swim() {System.out.println(老师游泳);}};go(pwimming);System.out.println();// 简化Pwimming pwimming1 () -{System.out.println(学生游泳);};go(pwimming1);System.out.println();// 再简化go(() - {System.out.println(运动员游泳);});// 再简化System.out.println();go(() - System.out.println(我游泳));}public static void go(Pwimming pwimming){System.out.println(开始。。。);pwimming.swim();System.out.println(结束。。。);}}FunctionalInterface // 一旦加上这个注解必须是函数式接口里面只能有一个抽象方法
interface Pwimming{void swim();
}import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;public class LambdaDemo3 {public static void main(String[] args) {Integer[] ages1 {34, 12, 42, 23};/**参数一被排序的数组 必须是引用类型的元素参数二匿名内部类对象代表了一个比较器对象。*/
// Arrays.sort(ages1, new ComparatorInteger() {
// Override
// public int compare(Integer o1, Integer o2) {
// return o2 - o1; // 降序
// }
// });// Arrays.sort(ages1, (Integer o1, Integer o2) - {
// return o2 - o1; // 降序
// });// Arrays.sort(ages1, ( o1, o2) - {
// return o2 - o1; // 降序
// });Arrays.sort(ages1, ( o1, o2 ) - o2 - o1 );System.out.println(Arrays.toString(ages1));System.out.println(---------------------------);JFrame win new JFrame(登录界面);JButton btn new JButton(我是一个很大的按钮);
// btn.addActionListener(new ActionListener() {
// Override
// public void actionPerformed(ActionEvent e) {
// System.out.println(有人点我点我点我);
// }
// });// btn.addActionListener((ActionEvent e) - {
// System.out.println(有人点我点我点我);
// });// btn.addActionListener(( e) - {
// System.out.println(有人点我点我点我);
// });// btn.addActionListener( e - {
// System.out.println(有人点我点我点我);
// });btn.addActionListener( e - System.out.println(有人点我点我点我) );win.add(btn);win.setSize(400, 300);win.setVisible(true);}
}Stream流 获取Stream流方式
public class StreamDemo02 {public static void main(String[] args) {/** --------------------Collection集合获取流------------------------------- */CollectionString list new ArrayList();StreamString s list.stream();/** --------------------Map集合获取流------------------------------- */MapString, Integer maps new HashMap();// 键流StreamString keyStream maps.keySet().stream();// 值流StreamInteger valueStream maps.values().stream();// 键值对流拿整体StreamMap.EntryString,Integer keyAndValueStream maps.entrySet().stream();/** ---------------------数组获取流------------------------------ */String[] names {赵敏,小昭,灭绝,周芷若};StreamString nameStream Arrays.stream(names);StreamString nameStream2 Stream.of(names);}
}/**目标Stream流的常用APIforEach : 逐一处理(遍历)count统计个数-- long count();filter : 过滤元素-- StreamT filter(Predicate? super T predicate)limit : 取前几个元素skip : 跳过前几个map : 加工方法concat : 合并流。*/
public class StreamDemo03_My {public static void main(String[] args) {ListString list new ArrayList();list.add(张无忌);list.add(周芷若);list.add(赵敏);list.add(张强);list.add(张三丰);list.add(张三丰);list.stream().filter(s - s.startsWith(张)).forEach(System.out::println);long count list.stream().filter(s - s.length() 3).count();System.out.println(count);list.stream().filter(s - s.startsWith(张)).limit(2).forEach(System.out::println);list.stream().filter(s - s.startsWith(张)).skip(2).forEach(System.out::println);// map加工方法: 第一个参数原材料 - 第二个参数是加工后的结果。// 给集合元素的前面都加上一个黑马的list.stream().map(s - 黑马的:s).forEach(System.out::println);ListStudent collect list.stream().map(s - {Student student new Student(s);return student;}).collect(Collectors.toList());System.out.println(collect);// 合并流。StreamString stream list.stream().filter(s - s.startsWith(张));StreamString java1 Stream.of(java1, java2);StreamString concat Stream.concat(stream,java1);System.out.println(concat);}}/**目标收集Stream流的数据到 集合或者数组中去。*/
public class StreamDemo05 {public static void main(String[] args) {ListString list new ArrayList();list.add(张无忌);list.add(周芷若);list.add(赵敏);list.add(张强);list.add(张三丰);list.add(张三丰);StreamString s1 list.stream().filter(s - s.startsWith(张));ListString zhangList s1.collect(Collectors.toList()); // 可变集合zhangList.add(java1);System.out.println(zhangList);// ListString list1 s1.toList(); // 得到不可变集合
// list1.add(java);
// System.out.println(list1);// 注意注意注意“流只能使用一次”StreamString s2 list.stream().filter(s - s.startsWith(张));SetString zhangSet s2.collect(Collectors.toSet());System.out.println(zhangSet);StreamString s3 list.stream().filter(s - s.startsWith(张));
// Object[] arrs s3.toArray();
// String[] arrs s3.toArray(s - new String[s]); // 可以不管拓展一下思维String[] arrs1 s3.toArray(String[]::new); // 可以不管拓展一下思维System.out.println(Arrays数组内容 Arrays.toString(arrs1));}
}反射 反射的第一步获取Class对象
/**目标反射的第一步获取Class对象*/
public class Test {public static void main(String[] args) throws Exception {// 1、Class类中的一个静态方法forName(全限名包名 类名)Class c Class.forName(com.itheima.d2_reflect_class.Student);System.out.println(c); // Student.class// 2、类名.classClass c1 Student.class;System.out.println(c1);// 3、对象.getClass() 获取对象对应类的Class对象。Student s new Student();Class c2 s.getClass();System.out.println(c2);}
}使用反射获取构造器对象
/**目标反射_获取Constructor构造器对象.反射的第一步是先得到Class类对象。Class文件反射中Class类型获取构造器提供了很多的API:1. Constructor getConstructor(Class... parameterTypes)根据参数匹配获取某个构造器只能拿public修饰的构造器几乎不用2. Constructor getDeclaredConstructor(Class... parameterTypes)根据参数匹配获取某个构造器只要申明就可以定位不关心权限修饰符建议使用3. Constructor[] getConstructors()获取所有的构造器只能拿public修饰的构造器。几乎不用太弱了4. Constructor[] getDeclaredConstructors()获取所有申明的构造器只要你写我就能拿到无所谓权限。建议使用小结获取类的全部构造器对象 Constructor[] getDeclaredConstructors()-- 获取所有申明的构造器只要你写我就能拿到无所谓权限。建议使用获取类的某个构造器对象Constructor getDeclaredConstructor(Class... parameterTypes)-- 根据参数匹配获取某个构造器只要申明就可以定位不关心权限修饰符建议使用*/
public class TestStudent01 {// 1. getConstructors:// 获取全部的构造器只能获取public修饰的构造器。// Constructor[] getConstructors()Testpublic void getConstructors(){// a.第一步获取类对象Class c Student.class;// b.提取类中的全部的构造器对象(这里只能拿public修饰)Constructor[] constructors c.getConstructors();// c.遍历构造器for (Constructor constructor : constructors) {System.out.println(constructor.getName() constructor.getParameterCount());}}// 2.getDeclaredConstructors():// 获取全部的构造器只要你敢写这里就能拿到无所谓权限是否可及。Testpublic void getDeclaredConstructors(){// a.第一步获取类对象Class c Student.class;// b.提取类中的全部的构造器对象Constructor[] constructors c.getDeclaredConstructors();// c.遍历构造器for (Constructor constructor : constructors) {System.out.println(constructor.getName() constructor.getParameterCount());}}// 3.getConstructor(Class... parameterTypes)// 获取某个构造器只能拿public修饰的某个构造器Testpublic void getConstructor() throws Exception {// a.第一步获取类对象Class c Student.class;// b.定位单个构造器对象 (按照参数定位无参数构造器 只能拿public修饰的某个构造器)Constructor cons c.getConstructor();System.out.println(cons.getName() cons.getParameterCount());}// 4.getConstructor(Class... parameterTypes)// 获取某个构造器只要你敢写这里就能拿到无所谓权限是否可及。Testpublic void getDeclaredConstructor() throws Exception {// a.第一步获取类对象Class c Student.class;// b.定位单个构造器对象 (按照参数定位无参数构造器)Constructor cons c.getDeclaredConstructor();System.out.println(cons.getName() cons.getParameterCount());// c.定位某个有参构造器Constructor cons1 c.getDeclaredConstructor(String.class, int.class);System.out.println(cons1.getName() cons1.getParameterCount());}}/**目标: 反射_获取Constructor构造器然后通过这个构造器初始化对象。反射获取Class中的构造器对象Constructor作用也是初始化并得到类的一个对象返回。Constructor的API:1. T newInstance(Object... initargs)创建对象注入构造器需要的数据。2. void setAccessible(true)修改访问权限true代表暴力攻破权限false表示保留不可访问权限(暴力反射)小结可以通过定位类的构造器对象。如果构造器对象没有访问权限可以通过void setAccessible(true)打开权限构造器可以通过T newInstance(Object... initargs)调用自己传入参数*/
public class TestStudent02 {// 1.调用构造器得到一个类的对象返回。Testpublic void getDeclaredConstructor() throws Exception {// a.第一步获取类对象Class c Student.class;// b.定位单个构造器对象 (按照参数定位无参数构造器)Constructor cons c.getDeclaredConstructor();System.out.println(cons.getName() cons.getParameterCount());// 如果遇到了私有的构造器可以暴力反射cons.setAccessible(true); // 权限被打开Student s (Student) cons.newInstance();System.out.println(s);System.out.println(-------------------);// c.定位某个有参构造器Constructor cons1 c.getDeclaredConstructor(String.class, int.class);System.out.println(cons1.getName() cons1.getParameterCount());Student s1 (Student) cons1.newInstance(孙悟空, 1000);System.out.println(s1);}}/**目标反射获取成员变量: 取值和赋值。Field的方法给成员变量赋值和取值void set(Object obj, Object value)给对象注入某个成员变量数据Object get(Object obj):获取对象的成员变量的值。void setAccessible(true);暴力反射设置为可以直接访问私有类型的属性。Class getType(); 获取属性的类型返回Class对象。String getName(); 获取属性的名称。*/
public class FieldDemo02 {Testpublic void setField() throws Exception {// a.反射第一步获取类对象Class c Student.class;// b.提取某个成员变量Field ageF c.getDeclaredField(age);ageF.setAccessible(true); // 暴力打开权限// c.赋值Student s new Student();ageF.set(s , 18); // s.setAge(18);System.out.println(s);// d、取值int age (int) ageF.get(s);System.out.println(age);}
}/**目标反射——获取Method方法对象反射获取类的Method方法对象1、Method getMethod(String name,Class...args);根据方法名和参数类型获得对应的方法对象只能获得public的2、Method getDeclaredMethod(String name,Class...args);根据方法名和参数类型获得对应的方法对象包括private的3、Method[] getMethods();获得类中的所有成员方法对象返回数组只能获得public修饰的且包含父类的4、Method[] getDeclaredMethods();获得类中的所有成员方法对象返回数组,只获得本类申明的方法。Method的方法执行Object invoke(Object obj, Object... args)参数一触发的是哪个对象的方法执行。参数二 args调用方法时传递的实际参数*/
public class MethodDemo01 {/*** 1.获得类中的所有成员方法对象*/Testpublic void getDeclaredMethods(){// a.获取类对象Class c Dog.class;// b.提取全部方法包括私有的Method[] methods c.getDeclaredMethods();// c.遍历全部方法for (Method method : methods) {System.out.println(method.getName() 返回值类型 method.getReturnType() 参数个数 method.getParameterCount());}}/*** 2. 获取某个方法对象*/Testpublic void getDeclardMethod() throws Exception {// a.获取类对象Class c Dog.class;// b.提取单个方法对象Method m c.getDeclaredMethod(eat);Method m2 c.getDeclaredMethod(eat, String.class);// 暴力打开权限了m.setAccessible(true);m2.setAccessible(true);// c.触发方法的执行Dog d new Dog();// 注意方法如果是没有结果回来的那么返回的是null.Object result m.invoke(d);System.out.println(result);Object result2 m2.invoke(d, 骨头);System.out.println(result2);}
}注解 public interface Book {String value(); // 特殊属性double price() ;//double price() default 9.9;
}Target({ElementType.TYPE,ElementType.METHOD})
Retention(RetentionPolicy.RUNTIME)
public interface Bookk {String value();double price() default 100;String[] author();
}
/**目标学会自定义注解。掌握其定义格式和语法。*/
MyBook(name《精通JavaSE》,authors {黑马, dlei} , price 199.5)
//Book(value /delete)
// Book(/delete)
Book(value /delete, price 23.5)
//Book(/delete)
public class AnnotationDemo1 {MyBook(name《精通JavaSE2》,authors {黑马, dlei} , price 199.5)private AnnotationDemo1(){}MyBook(name《精通JavaSE1》,authors {黑马, dlei} , price 199.5)public static void main(String[] args) {MyBook(name《精通JavaSE2》,authors {黑马, dlei} , price 199.5)int age 21;}
}import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;Target({ElementType.METHOD,ElementType.FIELD}) // 元注解
Retention(RetentionPolicy.RUNTIME) // 一直活着在运行阶段这个注解也不消失
public interface MyTest {
}/**目标认识元注解*/
//MyTest // 只能注解方法和成员变量
public class AnnotationDemo2 {MyTestprivate String name;MyTestpublic void test(){}public static void main(String[] args) {}
}/**目标完成注解的解析*/
public class AnnotationDemo3 {Testpublic void parseClass(){// a.先得到类对象Class c BookStore.class;// b.判断这个类上面是否存在这个注解if(c.isAnnotationPresent(Bookk.class)){//c.直接获取该注解对象Bookk book (Bookk) c.getDeclaredAnnotation(Bookk.class);System.out.println(book.value());System.out.println(book.price());System.out.println(Arrays.toString(book.author()));}}Testpublic void parseMethod() throws NoSuchMethodException {// a.先得到类对象Class c BookStore.class;Method m c.getDeclaredMethod(test);// b.判断这个类上面是否存在这个注解if(m.isAnnotationPresent(Bookk.class)){//c.直接获取该注解对象Bookk book (Bookk) m.getDeclaredAnnotation(Bookk.class);System.out.println(book.value());System.out.println(book.price());System.out.println(Arrays.toString(book.author()));}}
}Bookk(value 《情深深雨濛濛》, price 99.9, author {琼瑶, dlei})
class BookStore{Bookk(value 《三少爷的剑》, price 399.9, author {古龙, 熊耀华})public void test(){}
}动态代理 定义一个需要代理的接口
/*** author* create 2022-06-23 9:24*/
public interface Skill {void jump(); // 唱歌void sing(); // 跳舞}实现该接口
/*** author* create 2022-06-23 9:25*/
public class Star implements Skill{private String name;public Star(String name) {this.name name;}Overridepublic void jump() {System.out.println(name开始跳舞条的好看);}Overridepublic void sing() {System.out.println(name开始唱歌喵喵喵);}
}设计一个方法来返回对象的代理对象
/*** author* create 2022-06-23 9:28*/
public class StarAgentProxy {/*** 设计一个方法来返回对象的代理对象*/public static Skill getProxy(Star obj){// 为杨超越这个对象生成一个代理对象return (Skill) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 参数一代理对象本身。一般不管// 参数二正在被代理的方法// 参数三被代理方法应该传入的参数System.out.println(收首付款);// 真正让杨超越调用的方法对象Object invoke method.invoke(obj, args);System.out.println(经纪人收尾款);return invoke;}});}
}测试动态代理模式
/*** author* create 2022-06-23 9:26*/
public class Test {public static void main(String[] args) {// 目标学习开发一个动态代理的对象理解动态代理的执行流程// 1.创建一个对象对象的类必须实现接口Star s new Star(杨超越);// 为杨超越生成一个代理对象(经纪人)Skill proxy StarAgentProxy.getProxy(s);proxy.jump();proxy.sing();}
}
