1.死锁的条件：
死锁的产生还涉及到一些具体的条件，这些条件可以被看作是死锁产生的必要条件，包括：
1.互斥条件：资源不能被多个进程或线程同时访问，即资源是互斥的。
2.请求保持条件：进程或线程在请求资源时，已经持有其他资源，并且不愿意释放已经持有的资源。
3.不可剥夺条件：已经分配给进程或线程的资源，在未使用完之前不能被其他进程或线程剥夺。
4.循环等待条件：多个进程或线程之间形成一个循环等待链，每个进程或线程都在等待链中下一个进程或线程释放资源。
2.反射的概念：
程序运行期间，可以动态地获取类的内容（属性/方法/构造方法）的机制（思想），这种机制的实现称作反射。
解释：
Java语言是面向对象的，有对象必须先有类，在Java中存储了类的内容，这个内容也是一个对象。Java中的每一个类都有单独的内存，所以每一个类的内存都是一个对象，这些对象用来记录这些类中声明了哪些属性、方法、构造方法。
Java将这些类抽象为一个类：Class类
Class类的对象是不能new出来的，要用下面三种方法创建Class类对象：
1.通过类名的方式创建Class类对象
public class EasyClassA {
public static void main(String[] args) {
//通过类名获取类的类对象
Class clazz = EasyClassA.class;
System.out.println(clazz);
}
}2.通过对象获取类对象
public class EasyClassA {
public static void main(String[] args) {
//通过对象获取类对象
Class clazz = new EasyClassA().getClass();
System.out.println(clazz);
}
}3.通过Class方法的forName方法获取;
public class EasyClassA {
public static void main(String[] args) {
//通过Class方法的forName方法获取
try {
Class clazz = Class.forName("com.easy0725.EasyColor");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
System.out.println(clazz);
}
}3.Class类中记录类属性的对象的类是FIeld类
先创建一个Easy类：
public class Easy {
public String name;
protected String code;
String sex;
private String address;
static int maxAge;
public static volatile String test=null;
public Easy(){}
public Easy(String name){
this.name=name;
}
public void methodA(){
System.out.println("methodA");
}
public void methodB(int a,int b){
System.out.println("methodB");
System.out.println("两个参数分别为："+a+","+b);
}
}
fName变量指向的对象就是Easy类中的name属性：
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
//获取类对象
Class c = Easy.class;
//获取类的属性
//Java中用来记录类的属性的类叫做Field
//fName变量指向的对象就是Easy类中的name属性
Field fName=c.getField("name");
//可以通过fName获取某一个Easy类的对象的name属性的值
Easy easy=new Easy();
easy.name="张三";
System.out.println(easy.name);//输出：张三
//可以通过fName获取某一个Easy类的对象的name属性的值
Object objectName=fName.get(easy);
System.out.println(objectName+"-----------");//输出：张三------------
//可以通过fName注入某一个Easy类的对象的name属性的值
fName.set(easy,"李四");
System.out.println(easy.name);
}getField()和getFields() 只能获取类中的public声明的属性
getDeclaredField()方法和getDeclaredFields()方法可以获取别的类型的值（protected、default）
//getField和getFields 只能获取类中的public声明的属性
Field fCode=c.getDeclaredField("code");//使用getDeclaredField方法可以获取别的类型的值
fCode.set(easy,"10000");
Object objectCode=fCode.get(easy);//通过反射获取easy对象的code属性的值
System.out.println(objectCode);访问private的属性时要先获取访问权限
Field fSex=c.getDeclaredField("sex");
Field fAddress=c.getDeclaredField("address");
fSex.set(easy,"女");
//反射访问私有属性 必须先获取访问权限
fAddress.setAccessible(true);//将访问权限设置为true，就可以访问了
fAddress.set(easy,"青岛");
System.out.println(fAddress.get(easy));4.通过键值对存储在Map中的实例：
先创建一个学生类：
class Student{
private String name;
private String code;
private String sex;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", code='" + code + '\'' +
", sex='" + sex + '\'' +
'}';
}
}利用泛型，创建一个方法：
public class EasyClassC {
public static <T> T getInstance(Class<T> tClass, Map values) throws InstantiationException, IllegalAccessException {
//通过反射获取实例 创建对象
T t=tClass.newInstance();//通过类中的无参构造方法创建对象
//通过反射获取类中定义的属性
Field[] farr=tClass.getDeclaredFields();
//System.out.println(Arrays.toString(farr));
for (Field fitem:farr){
//获取属性的名字
String fname=fitem.getName();//获取属性的名字
//获取该属性在Map中的键值对 属性对应的值
Object value=values.get(fname);
//设置访问权限
fitem.setAccessible(true);
//注入
fitem.set(t,value);
}
return t;
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
Map map = new HashMap();
map.put("name","张三");
map.put("code","C1001");
map.put("sex","女");
Student stu = getInstance(Student.class,map);
System.out.println(stu);
}5.Class类中记录类的方法的对象的类是Method类：
在调用类的方法的对象时，要使用invoke()方法
正常在调用方法时：
原来的写法: 对象.方法名(参数)
反射中的写法: method对象.invoke(对象)
public class EasyClassD {
public static void main(String[] args) throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
Class<Easy> c = Easy.class;
//反射获取方法 Method类用来存储类对象的方法
Method ma=c.getMethod("methodA");
Easy easy = c.newInstance();
//调用这个方法
ma.invoke(easy);
Method mb = c.getMethod("methodB", int.class, int.class);//传入参数时的写法
mb.invoke(easy,2,13);
}
}6.Class类中记录类的构造方法的对象的类是Constructor类
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException, IntrospectionException {
//反射获取构造方法
Class<Easy> c = Easy.class;
//可以通过newInstance直接创建对象
c.newInstance();
//获取无参构造方法
Constructor<Easy> con = c.getConstructor();//构造方法名确定，只需要传入参数列表
con.newInstance();//无参的构造方法
con=c.getConstructor(String.class);//字符串参数的构造方法
con.newInstance("张三");
//修饰符
//使用Modifier的方法判断属性/方法/构造方法的修饰符
Field f = c.getDeclaredField("test");
int fmod = f.getModifiers();//获取属性的修饰符的类型
boolean bool = Modifier.isStatic(fmod);
System.out.println(bool);
}7.内省
内省：也是通过反射来实现的 内省不会破坏封装性
内省 :底层是通过反射实现,内省获取属性的读方法和写方法(getter/setter)来获取和设置属性的内容,不会破坏类的封装性
//内省 也是通过反射来实现的 内省不会破坏封装性
//内省 :底层是通过反射实现,内省获取属性的读方法和写方法(getter/setter)来获取和设置属性的内容,不会破坏类的封装性
//获取BeanInfo、
BeanInfo bi = Introspector.getBeanInfo(c);
//获取某一个属性写的方法和读的方法 setter/getter
PropertyDescriptor[] pds = bi.getPropertyDescriptors();
System.out.println(Arrays.toString(pds));
String pName = pds[0].getName();//获取属性的名字
Method read = pds[0].getReadMethod();//获取该属性的getter方法
Method write = pds[0].getWriteMethod();//获取该属性的setter方法
//obj.setName("zhangsan");
//write.invoke(obj,"zhangsan");
Easy easy = c.newInstance();
write.invoke(easy,"zhangsan");8.HTML
1.标签
1.页面标题：
2.<h><h/>标题，从h1~h6依次缩小：
3. <p></p>段落标签
4.图片
<img>
<img>中的src写的是图片复制到HBuilder当前文件中的图片
alt是在这个路径找不到图片时显示在网页上的文字
5.超链接
<a></a>超链接
超链接中href后写的是点击超链接后要跳转的地址，在<a></a>中的文字是超链接在网页上呈现的形式
图片也可以当作超链接，href后跟的也可以是HBuilder中的一个网页。
6.表格
<table></table> 表格
做一个四行四列表格，并把其中几项合并：
7.列表
列表分为有序列表（有序号）和无序列表 （无序号）
有序列表<ol></ol>
无序列表<ul></ul>
842
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
