Java学习系列01-Java基础

1、Eclipse的使用

第一次打开My Eclipse，会要求设置工作空间所在目录,这里一定要注意的是，路径不能带中文和空格

如何配置Java的编译环境、和运行环境

在Java开发中，有时遇到这样的错误 Bad vsersion number in .class file
这个是因为工程的编译环境使用的JDK版本比现在运行的JDK版本高

在Eclipse中如何调试代码，在调试中常用的快捷键
F5: step into　　F6:step over　　F7:step return

drop to frane:跳到当前方法的第一行　　resume:跳到下一个断点，如果没有下一个断点，则运行完

watch:观察变量或表达式的值，在调试模式，右键菜单中选择

断点注意的问题：

1.断点调试完毕之后，要在breakpoints视图中清除所有的断点

2.要中断Java虚拟机

 

2、Juint的简单使用

先写一个Person类

package cn.aixinsoft.eclipse;

public class Person {
    public void eat()
    {
        System.out.print("吃东西");
    }
    public void run()
    {
        System.out.print("跑步");
    }
}

在写完Person类之后，我们使用Juint类方法来测试

package cn.aixinsoft.eclipse;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class TestPerson {
    private Person per=null;
    @BeforeClass
    public static void BeforeClass()
    {
        System.out.println("BeforeClass");
    }
    @Before
    public void Before()
    {
        per=new Person();
        System.out.println("Before");
    }
    
    @Test
    public void TestEat()
    {
        per.eat();
    }
    @Test
    public void TestRun()
    {
        per.run();
    }
    @After
    public void After()
    {
        System.out.println("After");
    }
    
    @AfterClass
    public static void AfterClass()
    {
        System.out.println("AfterClass");
    }
}

Java中的断言:Assert.assertEquals("1","2");

3、JDK5.0的新特性

JDK中新增了许多新的Java特性，利用这些语法可以帮助开发人员编写更加高效、清晰、安全的代码

静态导入：用于简化程序对类静态属性和方法的调用

语法：Import static 包名.类名.静态属性|静态方法

例如:

package cn.aixinsoft.Demo1;
import static java.lang.System.out;
public class demo1 {
    public static void main(String [] ars)
    {
        out.print("静态导入");
    }
}

自动装箱/拆箱

装箱:指开发人员可以把一个基本数据类型直接赋值给对应的包装类型; 　　拆箱:指开发人员可以把一个包装类对象直接赋给对应的基本数据类型

典型的应用:

  List list=(List) new ArrayList();
  list.add(1);
  int j=(Integer)list.get(0);

增加for循环:主要用于遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦；增强for循环只能用在数组、或者实现Iterable接口的集合类上

语法格式:

for(变量类型 变量:需要迭代的数组或集合){

}

在Eclipse中，使用 Ctrl+T可以查看一个类的继承关系

package cn.aixinsoft.Demo1;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

import org.junit.Test;

public class Demo2 {

    /**
     * @增强for
     */
    @Test
    public  void test1() {
    int arr[]={1,2,3};
    for(int num :arr){
        System.out.println(num);
    }

    }
    @Test
    public  void test2() {
        List list=new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        for(Object obj:list){
            int i=(Integer)obj;
            System.out.println(i);
        }

    }
    
    @Test
    public  void test3() {
        Map map=new LinkedHashMap();
        map.put("1", "win");
        map.put("2", "winloa");
        map.put("3", "winloa1");
        //传统方式1
        Set set=map.keySet();
        Iterator it=set.iterator();
        while(it.hasNext()){
            String key=(String) it.next();
            String value=(String) map.get(key);
            System.out.println(key+" "+value);
        }
        
        //传送方式2
        Set set2=map.entrySet();
        Iterator it1=set2.iterator();
        while(it.hasNext()){
            Map.Entry entry=(Entry) it1.next();
            String key=(String) entry.getKey();
            String value=(String) entry.getValue();
        }
        
        
    }
    
    
    @Test
    public  void test4() {
        Map map=new LinkedHashMap();
        map.put("1", "win");
        map.put("2", "winloa");
        map.put("3", "winloa1");
        //增强for循环方式1
        for(Object obj:map.keySet())
        {
            String key=(String) obj;
            String value=(String) map.get(key);
        }
    }
    
    @Test
    public  void test5() {
        Map map=new LinkedHashMap();
        map.put("1", "win");
        map.put("2", "winloa");
        map.put("3", "winloa1");
        //增强for循环方式2
        for(Object obj:map.entrySet())
        {
            Map.Entry ent=(Entry) obj;
            String key=(String) ent.getKey();
            String value=(String) ent.getValue();
            System.out.println(key+"\t"+value);
        }
    }
    
    //增强for的需要注意的项:增强for只适合取数据，如果要修改的话，就要用传统的for循环
    @Test 
    public  void test6() {
        int arr[]={1,2,3};
        for(int i:arr){
            i=10;
        }
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

可变参数

package cn.aixinsoft.Demo1;

import org.junit.Test;


public class Demo3 {
    //可变参数
    @Test
    public void testSum()
    {
        sum(1,2,3,4,5);//调用方式1
        int arr[]={1,2,3,4,5,6};
        sum(arr);
    }
    //可变参数
    public void sum(int ...nums)
    {
        int sum=0;
        for(int i:nums){
            sum+=i;
        }
        System.out.println(sum);
    }
    //可变参数使用注意：可变参数一定是参数列表中最后1个
    public void sum1(int ...nums)
    {
        int sum=0;
        for(int i:nums){
            sum+=i;
        }
        System.out.println(sum);
    }
    
}

枚举:为什么需要枚举？

一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，此类问题在JDK5采用自定义带有枚举功能的类解决，Java5以后可以直接使用枚举予以解决；JDK5新增的enum关键字用于定义一个枚举类

package cn.ainxinsoft.enumeration;

import org.junit.Test;

public class Demo1 {
    //Java5以前
    public void printGrade(Grade grade)
    {
        
    }
    //Java5中的枚举
    public void printGrade1(Grade1 grade)
    {
        
    }
    @Test
    public void testprintGrade2()
    {
        printGrade2(Grade2.A);
    }
    @Test
    public void printGrade2(Grade2 grade)
    {
        String value=grade.getValue();
        System.out.println(value);
        System.out.println("");
        String str=grade.toLocalValue();
        System.out.println(str);
        
    }
}
class Grade
{
    private Grade(){
        
    }
    public static Grade A=new Grade();
    public static Grade B=new Grade();
    public static Grade C=new Grade();
    public static Grade D=new Grade();
    public static Grade E=new Grade();
}

enum Grade1 //简单的枚举
{
    A,B,C,D,E
}
enum Grade2 //带有更多信息的枚举
{
    A("100-90")
    {
        public String toLocalValue()
        {
            return "优";
        }
    },B("89-80"){
        public String toLocalValue()
        {
            return "良";
        }
        },C("79-70"){
            public String toLocalValue()
            {
                return "中";
            }
        },D("69-60")
        {
            public String toLocalValue()
            {
                return "一般";
            }
        },E("50-0"){
            public String toLocalValue()
            {
                return "差";
            }
        };
    
    
    private String value;
    private Grade2(String vale)
    {
        this.value=value;
    }
    public String getValue() {
        return value;
    }
    public abstract String toLocalValue();
}

枚举总结:
枚举类实际一种特殊的形式的Java类；枚举类中声明枚举类的一个实例对象；

与Java中的普通类一样，在声明枚举类时，也可以声明属性、方法、和构造函数，但枚举类的构造函数必须为私有的

枚举类也可以实现接口、或继承抽象类

JDK5中扩展了switch语句，可以接受int,byte,char ,short，也可以接收一个枚举类型

若枚举只有一个枚举值，则可以当作单与态设计模式

Java中声明的枚举类，均是java.lang.Enum类的孩子，它继承了Enum类的所有方法。常用方法：

•name()

•ordinal()

•valueof(Class enumClass, String name)

values() 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

package cn.ainxinsoft.enumeration;

import org.junit.Test;

public class Demo3 {
    @Test
    public void testWeekDay()
    {
        WeekDay week=WeekDay.WED;
        System.out.println(week.getLocalString());
    }
}
enum WeekDay
{
    MON("星期一"),TUE("星期二"),WED("星期三"),THU("星期四"),FRI("星期五"),SAT("星期六"),SUN("星期天");
    //public abstract String toLocalString();
    private String localString;
    private WeekDay(String toLocalString){
        this.localString=toLocalString;
    }
    public String getLocalString() {
        return localString;
    }
}

反射：Java中非常重要的技术，学习框架必知必会的东东

一个类有多个组成部分，例如：成员变量，方法，构造方法等。反射就是加载类，并解剖出类的各个组成部分。

Q：编程时什么情况下才需要加载类，并解剖出类的各个组成部分呢？

A ：反射技术一般用于框架，而框架有一个特点，就是基于配置文件，就是配置文件配置什么，就运行什么

加载类：Java中有一个Class类用于代表某一个类的字节码。

 　　Class类即然代表某个类的字节码，它当然就要提供加载某个类字节码的方法：forName()。forName方法用于加载某个类的字节码到内存中，并使用class对象进行封装

　　另外两种得到class对象的方式 1、类名.class　　　　　2、对象.getClass()

解剖类 Class对象提供了如下常用方法：

　　Public  Constructor  getConstructor(Class<?>... parameterTypes) 
　　Public  Method  getMethod(String name, Class<?>... parameterTypes) 
　　Public  Field  getField(String name)   public
　　public Constructor getDeclaredConstructor(Class... parameterTypes) 
　　public Method getDeclaredMethod(String name,Class... parameterTypes) 
　　public Field getDeclaredField(String name) 

　　这些方法分别用于从类中解剖出构造函数、方法和成员变量（属性）。解剖出的成员分别使用Constructor、 Method 、 Field 对象表示。

思考：假设你是一个框架的设计者，解剖出这些成员后你会干什么？

Eclipse小技巧： cls.getConstructor(String.class); 向这样的代码，把鼠标放在getConstructor上，然后出现提示Lable之后，按F2,就可以很快捷的搞定

利用Constructor创建对象 Constructor类提供了如下方法，用于创建类的对象：   public Object newInstance(Object... initargs)   initargs用于指定构造函数接收的参数

练习：反射类无参、有参、私有的构造函数，创建类的对象。

多学一招：sun公司为简化开发人员创建对象，它在class对象中也提供了一个newInstance方法，用于创建类的对象。这样开发人员可以避免每次都需要去反射Constructor 类以创建对象。 不过需要注意的是：class.newInstance方法内部是反射类无参的构造函数创建的对象，所以利用此种方式创建类对象时，类必须有一个无参的构造函数。

package cn.aixinsoft.reflect;

import java.util.List;

public class Person {
    public String UsrName="Winloa";
    public Person()
    {
        System.out.println("无参构造函数");
    }
    public Person(String name)
    {
        System.out.println("Person name");
    }

    public Person(String name,String pwd)
    {
        System.out.println("Person name and pwd");
    }
    
    public Person(List list)
    {
        System.out.println("List");
    }
}

 

package cn.aixinsoft.reflect;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class Demo2 {
    @Test
    public void test1() throws Exception
    {
        //反射构造函数
        Class cls=Class.forName("cn.aixinsoft.reflect.Person");
        Constructor c= cls.getConstructor(null);
        Person p=(Person) c.newInstance(null);
        System.out.println(p.UsrName);
    }
    //反射构造函数
    @Test
    public void Test2() throws Exception
    {
        Class cls=Class.forName("cn.aixinsoft.reflect.Person");
        Constructor c= cls.getConstructor(String.class);
        Person p=(Person) c.newInstance("用户名");
        System.out.println(p.UsrName);
    }
    
    //反射构造函数
    @Test
    public void Test3() throws Exception
    {
        Class cls=Class.forName("cn.aixinsoft.reflect.Person");
        Constructor c= cls.getConstructor(String.class,String.class);
        Person p=(Person) c.newInstance("用户名","1");
        System.out.println(p.UsrName);
    }
    
    //反射构造函数
    @Test
    public void Test4() throws Exception
    {
        Class cls=Class.forName("cn.aixinsoft.reflect.Person");
        Constructor c= cls.getConstructor(List.class);
        c.setAccessible(true);
        Person p=(Person) c.newInstance(new ArrayList());
        System.out.println(p.UsrName);
    }
    
    
    //创建对象的另一个方式，等效于test1
    @Test
    public void Test5() throws Exception
    {
        Class cls=Class.forName("cn.aixinsoft.reflect.Person");
        Person per=(Person) cls.newInstance();
    }
}

 

内省

元数据