黑马程序员 ---java基础加强01

4000

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！
----------------------

Eclipse调试

透视图和视图，eclipse左侧边框双击点击就是调试，设置断点，右键dubug as-->java application，换到调试透视图，选中变量右键watch就能看到变量的值了。

透视图就是小窗口的集合，视图就是小窗口，关闭后再打开在windowshowview中找。

如何设置单个工程的javac和java首选项——编译器。

运行和编译的版本要一致，低版本的编译可以在高版本运行器上运行.

静态导入impotr static：导入一个类中的静态方法。

可变参数：有时候要接受若干不确定个数参数的方法，public static int add（int x，int…args）可变参数后不能再有参数，方法体中以数组方法来用。

增强for循环：用在数组和集合，集合必须实现iterable接口。

享元模式flyweight：很多很小的的对象有很多相同的属性，可以把它们变成一个对象，这些相同的属性叫内部状态，不同的属性作为方法的参数，叫            
       做外部状态。

枚举：就是某个类型的变量只能取若干个固定值中的一个；

      枚举中可以有构造方法，但是其元素必须由枚举类的子类复写抽象方法得到的实例对象构成。

package cn.itcast.day1;

public class test {

public static void main(String[] args) {
TrafficLamp red=TrafficLamp.Red;
System.out.println(red.NextLamp());
System.out.println("this time is "+red.Time);
}

public enum TrafficLamp{
Red(30){
public TrafficLamp NextLamp() {
return GREEN;
}
},
GREEN(45){
public TrafficLamp NextLamp() {
return YELLOW;
}
},
YELLOW(5){
public TrafficLamp NextLamp() {
return Red;
}
};
//抽象方法
public abstract TrafficLamp NextLamp();
private int Time;

//枚举的有参构造函数
private TrafficLamp(int time) {
this.Time=time;
}
}
}

反射

从1.2开始就有了。框架中都要用到反射。了解反射先要了解class类。Class实例对象代表内存中字节码文件。

什么是字节码文件：就是二进制文件，用到类时从硬盘把类二进制代码编译成class二进制代码再加载到内存。得到字节码的三种方法：

1、Class cls1=Date.class；//类名.class

2、new Date（）.getClass（）//对象.getclass（）

3、Class.forName（“java.lang.String”）；//class.forname（“类名称”）

如果字节码在内存中存在则值直接返回，如果不存在则用类加载器把字节码加载到内存中再返回。

class.forname（）作用：返回字节码，jvm中有字节码则返回，如果没有则用类加载器加载。

九个预定义class实例对象，八个基本数据类型和void。都有对应class对象，Class cls=void.class();

判断是否数组类型的class实例对象，class.isArray()；

程序中出现类型都有各自class实例对象，基本数据类型和引用数据类型都有。

反射：就是把java类中的各种成分映射成相应的java类。

反射导致程序性能下降。

Field

字节码文件的成员变量类，不是对象上的而是类上的。所以要获得对应变量的具体值要传入对象名称。如果变量私有要进行暴力反射。getDeclaredField（“”），setAccessible（）设置为可以获取。

Method

字节码文件的方法类，Method一个对象对应一个方法

Constructor

字节码文件的构造函数类

import java.lang.reflect.*;
import java.util.Arrays;
public class ReflectTest {
public static void main(String[] args)throws Exception
{
String str1="acd";
Class cls1=str1.getClass();
Class cls2=String.class;
Class cls3=Class.forName("java.lang.String");
System.out.println(cls1==cls2);
System.out.println(cls1==cls3);

System.out.println(cls1.isPrimitive());
System.out.println(int.class.isPrimitive());
//int和Integer不是同一份字节码文件
System.out.println(int.class==Integer.class);
//Integer.TYPE表示所包装的类型
System.out.println(int.class==Integer.TYPE);
//数组不是原始类型
System.out.println(int[].class.isPrimitive());
//判断某个类型是否是数组类型
System.out.println(int[].class.isArray());

//Constructor类
//new String(new StringBuffer("abc"));
Constructor<String> con=String.class.getConstructor(StringBuffer.class);
String str=con.newInstance(new StringBuffer("abc"));
System.out.println(str.charAt(2));

//Field类
ReflectPoint pt1=new ReflectPoint(3,5);
Field f1=pt1.getClass().getField("y");//f1代表字节码文件中变量不是对象的值
System.out.println(f1.get(pt1));
//因为x为私有所以需要用getDeclaredField
Field f2=pt1.getClass().getDeclaredField("x");
//并且将f2(x的字节码值)变为可访问的
f2.setAccessible(true);
System.out.println(f2.get(pt1));

//将ReflectPoint中string变量中b改为a
changeValue(pt1);
System.out.println(pt1);

//方法的调用
Method methodCharAt=String.class.getMethod("charAt", int.class);
System.out.println(methodCharAt.invoke(str1, 2));

//调用主函数，为什么用反射调用主函数呢，因为不知道要调用哪个类
String startMethodName=args[0];
Method mainMethod=Class.forName(startMethodName).getMethod("main", String[].class);
//因为invoke中传递的main方法参数为了兼容1.4所以必须为含有一个元素的数组
mainMethod.invoke(null, (Object)new String[]{"111","222","222"});
//mainMethod.invoke(null, new Object(new String[]{"111","222","222"}));

//数组的反射
//Array类
int[] a1=new int[]{1,2,3};
int[] a2=new int[4];
int[][] a3=new int[2][3];
String[] a4=new String[]{"a","b","c"};
System.out.println(a1.getClass()==a2.getClass());
//System.out.println(a1.getClass()==a3.getClass());
//System.out.println(a1.getClass()==a4.getClass());
System.out.println(a1.getClass().getName());
System.out.println(a1.getClass().getSuperclass().getName());
System.out.println(a4.getClass().getSuperclass().getName());

printObject(a1);
printObject(a4);
}

public static void printObject(Object obj)
{
Class clazz=obj.getClass();
if(clazz.isArray())
{
int len=Array.getLength(obj);//getlength方法属于Reflect.Array类中
for(int i=0;i<len;i++)
{
System.out.print(Array.get(obj, i));
}
}
else
{
System.out.println(obj);
}
}
public static void changeValue(Object obj)throws Exception
{
Field[] fields=obj.getClass().getFields();
for(Field field:fields)
{
if(field.getType()==String.class)
{
String oldValue=(String)field.get(obj);
String newValue=oldValue.replace('b','a');
field.set(obj, newValue);
}
}
}
}
class TestArguments
{
public static void main(String[] args)
{
for(String arg:args)
{
System.out.println(arg);
}
}
}

hashCode（）的作用： ①HashSet集合中保证元素的唯一性就是通过先判断hashCode是否相同，如果相同才会调用equals（）方法

                    ②对于一个已经存入了HashSet集合中的对象，不可以修改参与了计算哈希值的字段，如果修改，修改后的对象会获得一个新的 哈希值存在于内存中，对其进行删除操作，只会删除当前的对象，而不会删除之前的对象，如此不断进行修改，可能会导致内                       存溢出。

反射开发框架原理

package cn.itcast.day1;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Properties;

public class ReflectPoint {

public static void main(String[] args)throws Exception
{

InputStream in = new FileInputStream("config.properties");

Properties pros = new Properties();

pros.load(in);
String className = pros.getProperty("className");

Collection collections = (Collection)Class.forName(className).newInstance();
//Collection collections = new ArrayList();

ReflectTest rt1 = new ReflectTest(3,3);
ReflectTest rt2 = new ReflectTest(4,4);
ReflectTest rt3 = new ReflectTest(3,3);

collections.add(rt1);
collections.add(rt2);
collections.add(rt3);
collections.add(rt1);

System.out.println(collections.size());
}