简单JAVA 1.5新特性
IDE（集成开发环境）Integrated DevelopmentEnvironment
MyEclipse 快捷键的模块设置
1、java5的静态导入
Importjava.lang.Math.*
2、可变参数与OverLoad
public class Demo{
public static void main(String[] args){
System.out.println(add(2,3));
System.out.println(add(2,3,5));
}
public static int add(int x,int…args) {
int sum=x;
for(int arg:args){
sun+=arg;
}
return sum;
}
}
3、增强for循环
普遍用数组与集合中的遍历元素
public class Demo {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for (Object obj:list){
System.out.println(obj);
}
}
}
4、泛型
(1)泛型是一种把明确类型放在了创建对象或者调用方法时候才去明确的特殊的类型。
(2)格式：
<数据类型>引用数据类型
(3)好处：
A:解决了黄色警告线问题
B:把运行期间的转换异常给提前到了编译期间
C:优化了程序设计，不需要做强制类型转换了
(4)泛型的前世今生
A:泛型类
B:泛型方法
C:泛型接口
(5)泛型的使用：(掌握)
看API中的类或者接口,其后是否跟有<>,如果有，就是泛型的应用。
一般在集合中用
public class Demo
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<Person>();
list.add(new Person("张三", 23));
list.add(new Person("李四", 24));
while(it.hasNext()) {
Person p = it.next();
System.out.println(p.getName() + "..." + p.getAge());
}
}
}
class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
}
(6) * 泛型的通配符
* ?
* 高级泛型
* ? extends E 固定上边界
* ? super E
import cn.itcast.bean.Person;
import cn.itcast.bean.Student;
public class Demo4_Generic {
public static void main(String[] args) {
//ArrayList<?> list = new ArrayList<String>();
ArrayList<Person> list1 = new ArrayList<>();
list1.add(new Person("张三", 23));
list1.add(new Person("李四", 24));
list1.add(new Person("王五", 25));
ArrayList<Student> list2 = new ArrayList<>();
list2.add(new Student());
list2.add(new Student());
list2.add(new Student());
list1.addAll(list2);
//list2.addAll(list1);
}
}
5、Integer(自动拆装箱）
public class Test {
public static void main(String[] args) {
Integer intObj = 20;//相当于：Integer intObj = new Integer(20);//自动装箱
int intValue = new Integer(20);//自动拆箱
int sum = intObj + intValue;
System.out.println("sum = " + sum);
}
}
6、枚举
(1)枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。
枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后面要有分号与其他成员分隔，把枚举的成员变量等放在枚举元素的前面，编译器报告错误。
(2)带构造方法的枚举
构造方法必须定义成私有的
如果有多个构造方法，该如何选择构造方法？
枚举元素MON和MON（）的效果一样，都是调用默认构造方法。
(3)带方法的枚举
定义枚举TrfficLamp
实现普通的next方法
实现抽象的next方法，每个元素分别是由枚举的子类生成的实例对象,这些子类采用类似内部类的方式进行定义。
增加上表示时间的构造方法。
(4)枚举只有一个成员时，就可以作为一种单例的实现方式。
public class Fu7 {
/**
* @param args
*/
public static void main(String[] args) {
Weekday1 weekday1=Weekday1.fir;
System.out.println(weekday1);
System.out.println(weekday1.ordinal());
System.out.println(weekday1.name());
System.out.println(weekday1.valueOf("sun"));
System.out.println(weekday1.values().length);
}
public enum Weekday1{
sun(1),mon,tue(1),wed,trt,fir,sat;
private Weekday1(){System.out.println("first");}
private Weekday1(int i){System.out.println("second");}
}
//实现带有抽象方法的枚举
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.Class
.class文件加载到内存中就是一个Class对象
获取Class对象的方式有3种:
Scannersc = new Scanner("xxx.txt");
Class.forName(sc.nextLine());
类名.class
对象.getClass()
import cn.itcast.bean.Person;
public class Demo1_Reflect {
/**
* @param args
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz1 = Class.forName("cn.itcast.bean.Person");
Class<?> clazz2 = Person.class;
Person p = new Person();
Class<?> clazz3 = p.getClass();
System.out.println(clazz1 == clazz2);
System.out.println(clazz2 == clazz3);
}
}
2.Constructor
Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了
可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数
然后再调用Constructor类的newInstance("张三",20)方法创建对象
import java.lang.reflect.Constructor;
import cn.itcast.bean.Person;
public class Demo3_Constructor {
/* @throws Exception
*/
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("cn.itcast.bean.Person");
/*Person p = (Person) clazz.newInstance();
System.out.println(p);*/
Constructor con = clazz.getConstructor(String.class,int.class);//获取有参的构造函数
Person p = (Person) con.newInstance("张三",23); //创建对象
System.out.println(p); //打印对象
}
}
3.Field
Class.getField(String)方法可以获取类中的指定字段(可见的), 如果是私有的可以用getDeclaedField("name")方法获取
通过set(obj,"李四")方法可以设置指定对象上该字段的值,如果是私有的需要先调用setAccessible(true)设置访问权限
用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import cn.itcast.bean.Person;
public class Demo4_Field {
/
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("cn.itcast.bean.Person");
Constructor con = clazz.getConstructor(String.class,int.class);//获取有参的构造函数
Person p = (Person) con.newInstance("张三",23); //创建对象
/*Field f = clazz.getField("name");
System.out.println(f);*/
Field f = clazz.getDeclaredField("name"); //暴力反射
f.setAccessible(true); //去除权限
f.set(p, "李四");
System.out.println(p);
}
}4.Method
Class.getMethod(String, Class...) 和Class.getDeclaredMethod(String, Class...)方法可以获取类中 的指定方法
调用invoke(Object, Object...)可以调用该方法
Class.getMethod("eat")invoke(obj) Class.getMethod("eat",int.class) invoke(obj,10)
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import cn.itcast.bean.Person;
public class Demo5_Method {
/ * @throws Exception
*/
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("cn.itcast.bean.Person");
Constructor con = clazz.getConstructor(String.class,int.class);//获取有参的构造函数
Person p = (Person) con.newInstance("张三",23); //创建对象
Method m = clazz.getMethod("eat");
m.invoke(p);
Method m2 = clazz.getMethod("eat", int.class);
m2.invoke(p, 10);
}
}
创建一个集合对象,泛型为String类型,需要向这个集合中添加Integer对象
* 泛型在编译时存在,运行时会被擦除
* 泛型反射
import java.lang.reflect.Method;
import java.util.ArrayList;
public class Test3 {
/* @throws Exception
*/
public static void main(String[] args) throws Exception {
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
Class<?> clazz = Class.forName("java.util.ArrayList"); //获取字节码文件
Method m = clazz.getMethod("add", Object.class); //获取方法
m.invoke(list, 1111); //执行方法
m.invoke(list, true);
System.out.println(list);
}}
具有相同的维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一位数组可以被当作Object类型使用，不能被当做Object[]类型使用，非基本类型数组，既可以当作Object类使用，又可以当作Object[]类型使用.
Arrays.asList()方法处理int[]和String[]时的差异
Array工具类可以完成对数组的反射。
import java.lang.reflect.Array;
import java.util.Arrays;
public class Demo {
public static void main(String[] args) {
int[] a1=new int[]{1,2,3};
int[] a2=new int[3];
int[][] a3=new int[2] [3];
String[]a4=new String []{"a","b","c"};
Object aObj1=a1;
Object aObj2=a4;
// Object[] aObj3=a1;
Object[] aObj4=a3;
Object[] aObj5=a4;
System.out.println(a1);
System.out.println(a4);
System.out.println(Arrays.asList(a1));
System.out.println(Arrays.asList(a4));
printObject(a4);
printObject("xyz");
}
private static void printObject(Object obj) {
Class clazz =obj.getClass();
if(clazz.isArray()){
int len=Array.getLength(obj);
for(int i=0;i<len;i++){
System.out.println(Array.get(obj, i));
}
}else{
System.out.println(obj);
}
}
}
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
