本文主要介绍的是枚举类,注解和反射。还有一些基础知识:static,基本数据类型,运算符优先级放在文中,以便查阅复习。
其中牵扯到泛型的部分,可参考本人的另一篇博客:(Collection, List, 泛型)JAVA集合框架一
static
可以修饰的有:属性,方法,代码块,内部类。
按是否用static
修饰分为静态属性和非静态属性(实例变量)。
非静态属性(实例变量):当创建了类的多个对象,每个对象都独立拥有自己的非静态属性。当修改其中一个对象中的非静态属性时,不会改变其他对象中的非静态属性。
静态属性(静态变量):当创建了类的多个对象,多个对象共享同一个静态对象。通过任一个对象改变静态属性,所有对象的静态属性都会发生改变。
class.静态变量
进行调用。静态方法:
类.静态方法
调用注意点:
this
和super
关键字,因为静态方法不需要实例化对象,而没有实例化对象this
就没有意义。一定要是同级的生命周期才能使用。JDK5.0新增enum
关键字
理解:
常用方法:
重点掌握:toString
,values
,valueOf
interface Info{
void show();
}
enum Season implements Info{
@Override
public void show() {
System.out.println("hello,world");
}
}
整体demo包含常用方法的使用:
public class EnumTest1 {
public static void main(String[] args) {
Season summer = Season.SUMMER;
System.out.println(summer); //SUMMER
System.out.println(Season.class.getSuperclass()); //class java.lang.Enum
System.out.println(summer.getSeasonFeel()); //hot
Season[] values = Season.values();
for(Object i : values){
System.out.println(i); //SPRING,SUMMER,AUTUMN,WINTER
}
Season winter = Season.valueOf("WINTER"); //根据字符串返回相应的enum,错误则出现异常
System.out.println(winter); //WINTER
winter.show();
}
}
interface Info{
void show();
}
enum Season implements Info{
SPRING("spring","warm"){
@Override
public void show() {
}
},
SUMMER("summer","hot"){
@Override
public void show() {
}
},
AUTUMN("autumn","cool"){
@Override
public void show() {
}
},
WINTER("winter","cold"){
@Override
public void show() {
}
};
private final String SeasonName;
private final String SeasonFeel;
Season(String seasonName, String seasonFeel) {
SeasonName = seasonName;
SeasonFeel = seasonFeel;
}
public String getSeasonName() {
return SeasonName;
}
public String getSeasonFeel() {
return SeasonFeel;
}
}
Thread
中线程状态利用的就是枚举类,可参考源码。
注解(Annotation)是代码里的特殊标记,这些标记可以在编译,类加载,运行时被读取,并执行相应的处理。通过使用注解,程序员可以在不改变原有逻辑的情况下,在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或进行部署。JDK5.0新增
在JavaSE
中注解的使用目的比较简单,比如标记过时功能,忽略警告等。在JavaEE
中占据了更重要的角色。后续博客将会继续JavaEE
的内容。
在一定程度上,框架 = 注解 + 反射 + 设计模式
/**
*/
类注释必须放在import
语句之后,类定义之前。
除了通用标记之外,还可以使用下面的标记:
@param
变量描述,这个标记将对当前方法的参数部分添加一个条目。这个描述可以占据多行,并可以使用HTML标记,一个方法的所有变量描述需要放在一起。
@return
描述
@throws
类描述,表示这个方法有可能抛出异常。
注意,一定要用 # 分隔类名和方法名,或类名和变量名。
//1
public @interface MyAnnotation {
String value();
}
@MyAnnotation(value = "hello") //使用时
//2
public @interface MyAnnotation {
String value() default "hello";
}
@MyAnnotation //默认值"hello",可覆盖
value
表示default
定义具体用途在反射和框架中。自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
元注解:用于修饰其他注解定义
例:
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
JDK5.0提供了4个标准的元注解:
Retention
, Target
, Documented
, Inherited
自定义注解通常都会使用以上两个元注解Retention, Target。
Repeatable()
@Repeatable(MyAnnotations.class)
public @interface MyAnnotation {
String value() default "hello";
}
public @interface MyAnnotations {
MyAnnotation[] value();
}
其中,MyAnnotation和MyAnnotations需要保持Retention和Target以及Inherited一致,在这部分只需要注意,在以后用到时再重点讲解。
反射机制提供的功能:
关于java.lang.Class类的理解:
三种Class实例的获取方式:
获取当前对象的类型对象,类型类是指代表一个类型的类,获取class
对象的方法有:1.类名.class,所有的引用数据类型和基本数据类型都可以通过这个方式获取。2.通过对象实例.getClass()来获得class
对象。3.调用Class的静态方法 Class.forName(String classPath)
例:
//调用运行时类的属性, .class
Class<Person> clazz1 = Person.class;//泛型可省略
System.out.println(clazz1); //class demo1.Person
//通过运行时类的对象
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);
//调用Class的静态方法 Class.forName(String classPath)
Class clazz3 = Class.forName("demo1.Person");
System.out.println(clazz3);
此外,还可以使用类的加载器ClassLoader
,不再详细赘述。
JDK8中对于自定义类的ClassLoader
属于系统类加载器,此外还有扩展类加载器和引导类加载器。
简述下方的Person
类:内部成员变量为public String name, private int age, 有公有构造器和私有构造器,有公有方法show()和私有方法show1(), 重写toString。
基本应用demo:
Class clazz = Person.class; //public age,private name
//通过反射,创建Person类的对象
Constructor cons = clazz.getConstructor(String.class,int.class);
Object obj = cons.newInstance("Tom",12);
Person p = (Person) obj;
System.out.println(p.toString()); //Person{name='Tom', age=12} 调用了Person类中的toString方法
System.out.println(cons); //public demo1.Person(java.lang.String,int)
//通过反射,调用对象指定的属性,方法
Field age = clazz.getDeclaredField("age");
age.set(p,10);
System.out.println(p.toString()); //Person{name='Tom', age=10}
Method show = clazz.getDeclaredMethod("show");
show.invoke(p); //sout("hello")
需要注意的是Class
对象并不能指明该类型的实例化,需要在Field
或Method
这种将实例放入参数中。
通过反射,可以调用Person类的私有结构,如:私有构造器,私有方法,私有属性。
//调用私有构造器
Constructor cons1 = clazz.getDeclaredConstructor(String.class);
cons1.setAccessible(true);
Person p1 = (Person)cons1.newInstance("tim");
System.out.println(p1); //Person{name='tim', age=0}
//调用私有属性
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p1,"Tim");
System.out.println(p1); //Person{name='Tim', age=0}
//调用私有方法
Method show1 = clazz.getDeclaredMethod("show1",String.class);
show1.setAccessible(true);
show1.invoke(p1,"H"); //world H,相当于p1.show1("H");
//.invoke返回的是object,强制转换
String str = (String)show1.invoke(p1,"H");
System.out.println(str); //H,p1.show1(str)返回了str。
这里和面向对象概念中的封装性可能有冲突,为什么要利用反射呢?
举个例子:反射具有动态性的特征。后台中,服务器的程序一直运行,假如从前端传来信息,后台就可以动态进行调用。动态过程中,可以利用反射进行应用。
Class<Person> clazz = Person.class;//使用泛型声明后下方不用强制转换,Person有public的空参构造器
Person obj = clazz.newInstance();//Person{name='null', age=0},内部其实调用了运行时类的空参构造器
System.out.println(obj);
Class clazz = Person.class;
//获取属性结构
//.getFields() 获取当前运行时类及其父类中声明为Public访问权限的属性
Field[] fields = clazz.getFields(); //public int demo1.Person.id, public double demo1.Creature.weight,只有public属性
for(Field f : fields){
System.out.println(f);
}
//.getDeclaredFields() 获得当前运行类中声明的所有属性(不包含父类)
Field[] declaredfields = clazz.getDeclaredFields();//省略为:name,age,id
for(Field f : declaredfields){
System.out.println(f);
}
Field[] declaredfields = clazz.getDeclaredFields();
for(Field f : declaredfields){
//1.权限修饰符
int modifier = f.getModifiers(); //修饰符以int表示,Modifier类中有相关代码
System.out.println(Modifier.toString(modifier)); //这样的话就可以正常显示public,private等了
//数据类型
Class type = f.getType();
System.out.println(type.getName()); //也可直接用type
//变量名
System.out.println(f.getName());
}
获得方法结构:
Class clazz = Person.class;
//获取当前运行时类和父类的Public方法
Method[] methods = clazz.getMethods();
for(Method m : methods){
System.out.println(m);
}
//获取当前运行时类声明的所有方法(不包含父类)
Method[] methods1 = clazz.getDeclaredMethods();
for(Method m : methods1){
System.out.println(m);
}
获取方法的内部结构:
Method[] methods = clazz.getDeclaredMethods();
for(Method m : methods){
//获取方法声明的注解
Annotation[] anno = m.getAnnotations();
for(Annotation i : anno){
System.out.println(i);
}
//得到每个方法的权限修饰符
System.out.println(Modifier.toString(m.getModifiers()));
//返回值类型
System.out.println(m.getReturnType().getName());
//方法名
System.out.println(m.getName());
//形参列表
Class[] paras = m.getParameterTypes();
//抛出的异常
Class[] exs = m.getExceptionTypes();
}
构造器等都类似,不再赘述。构造器的.getConstructors和.getDeclaredConstructors不能获取父类的结构,没有意义。
此外还可获取运行时类的父类和父类的泛型,运行时类的接口,包,注释等,代码比较机械,不再赘述。
调用运行时类的属性:
Class clazz = Person.class;
Person p = (Person) clazz.newInstance();
//.getField只能获取public,获取其他的话需要用.getDeclaredField()
//此外,假如下方是获取所有属性,则需要继续扩展权限,调用id.setAccessible(true);
Field id = clazz.getField("id");
//设置当前属性的值
id.set(p,12);
int i = (int)id.get(p); //返回object,需要强转
System.out.println(i);
调用运行时类中指定的方法:
Class clazz = Person.class;
Person p = (Person) clazz.newInstance();
//获取指定的某个方法
Method m = clazz.getDeclaredMethod("show1",String.class,String.class);
m.setAccessible(true);
//注意: .getDeclaredMethod,.invoke均需要两个参数
//需要注意的是如果方法有多个参数,需要全部标出来
m.invoke(p,"hello","hi"); //返回一个Object,可强转方法的返回类型
//调用静态方法
//private static void show1()
Method m = clazz.getDeclaredMethod("show1");
m.setAccessible(true);
m.invoke(Person.class);//写null也可以,不影响
如果调用的运行时类的方法没有返回值,则返回null
调用运行时类中指定的构造器:
Class<Person> clazz = Person.class;
Constructor cons = clazz.getDeclaredConstructor(String.class);
cons.setAccessible(true);
Person p = (Person) cons.newInstance("hi"); //Person{name='hi', age=0}
System.out.println(p);
需要注意的是即使Class加上泛型声明,下方的Constructor.newInstance仍需强转
接下来是最近刷题时总结了一些基础知识,需要对这些数据保持敏感。
byte
:
short
:
int
:整数型,4个字节32位,负数以补码形式存在,取值范围如下:
long
:
float
:
double
:
boolean
:
char
:
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://www.cnblogs.com/gaoyuan206/p/14757849.html
内容来源于网络,如有侵权,请联系作者删除!