Java--小知识点--类型转换

javaBean

public class Customer {
    private int id;
    private String name;
    public Customer(){
    }
    public void setId(int i){
        id = i;
    }
    public int getId(){
        return id;
    }
    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }
}

Object类的使用

java.lang.Object类
1.Object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能(属性、方法)就具有通用性。
属性：无
方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()
wait() 、 notify()、notifyAll()
4. Object类只声明了一个空参的构造器
面试题： final(关键字)、finally(关键字)、finalize(方法名，回收)的区别？

面试题： == 和 equals() 区别 *

一、回顾 == 的使用：
== ：运算符
1. 可以使用在基本数据类型变量和引用数据类型变量中
2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

二、equals()方法的使用：
1. 是一个方法，而非运算符
2. 只能适用于引用数据类型
3. Object类中equals()的定义：

     public boolean equals(Object obj) {
            return (this == obj);
      }

说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
4. 像String、Date、File、包装类等都重写了Object类中的equals()方法(这是特殊的)。重写以后，比较的不是
两个引用的地址是否相同，而是比较两个对象的”实体内容”是否相同。

5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的”实体内容”是否相同。那么，我们就需要对Object类中的equals()进行重写.
重写的原则：比较两个对象的实体内容是否相同.

Java中的JUnit单元测试

• 步骤：
  1.中当前工程 - 右键择：build path - add libraries - JUnit 4 - 下一步
  2.创建Java类，进行单元测试。
  此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器
  3.此类中声明单元测试方法。
  此时的单元测试方法：方法的权限是public,没返回值，没形参
  
  4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;
  
  5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
  6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test
  
  说明：
  1.如果执行结果没任何异常：绿条
  2.如果执行结果出现异常：红条

  包装类

  1.为什么要有包装类(或封装类）为了使基本数据类型的变量具有类的特征，引入包装类。

2.基本数据类型与对应的包装类：

3.需要掌握的类型间的转换：（基本数据类型、包装类、String）

//基本数据类型->包装类
//现在系统不建议用new的方法
int num1 = 10;
Integer in1 = new Integer(num1);//通过构造器
Integer in1 = new Integer("10");//通过字符串参数
Integer obj = Integer.valueOf(num1);//

简易版：

基本数据类型<—->包装类

• JDK 5.0 新特性：自动装箱 与自动拆箱

//自动装箱：基本数据类型 --->包装类
    int num2 = 10;
    Integer in1 = num2;//自动装箱
    boolean b1 = true;
    Boolean b2 = b1;//自动装箱
//自动拆箱：包装类--->基本数据类型
//System.out.println(in1.toString());
    int num3 = in1;//自动拆箱

基本数据类型、包装类—->String

• 调用String重载的valueOf(Xxx xxx)

//基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)
    public void test4(){
        int num1 = 10;
        //方式1：连接运算
        String str1 = num1 + "";
        //方式2：调用String的valueOf(Xxx xxx)
        float f1 = 12.3f;
        String str2 = String.valueOf(f1);//"12.3"
        Double d1 = new Double(12.4);
        String str3 = String.valueOf(d1);
        System.out.println(str2);
        System.out.println(str3);//"12.4"
    }

String—->基本数据类型、包装类

• 调用包装类的parseXxx(String s) 注意：转换时，可能会报NumberFormatException

    //String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
    public void test5(){
        String str1 = "123";
        //错误的情况：
//        int num1 = (int)str1;
//        Integer in1 = (Integer)str1;
        //可能会报NumberFormatException
        int num2 = Integer.parseInt(str1);
        System.out.println(num2 + 1);
        String str2 = "true1";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);
    }

应用场景举例

① Vector类中关于添加元素，只定义了形参为Object类型的方法：
v.addElement(Object obj); //基本数据类型 —->包装类 —->使用多态

面试题

如下两个题目输出结果相同吗？各是什么：

Object o1 = true ? new Integer(1) : new Double(2.0); 
System.out.println(o1);//1.0
//因为类型提升，int型变成double
//三元运算符
/*(关系表达式) ? 表达式1 : 表达式2;
int x = 10;
int y = 5;
int z;
如果x大于y 则是true，将x赋值给z；
如果x不大于y 则是false，将y赋值给z；
z = (x > y) ? x : y;
System.out.println("x = " + x);*/

Object o2;
if (true)
    o2 = new Integer(1);
else 
    o2 = new Double(2.0);
System.out.println(o2);//1

public void test3() {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);//false
        //Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
        //保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在
        //-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);//true,(-128~127的地址是固定的)
        Integer x = 128;//相当于new了一个Integer对象
        Integer y = 128;//相当于new了一个Integer对象
        System.out.println(x == y);//false，超出范围，相当于自己new了一个
    }

练习题

知识点Vector代替数组处理

利用Vector代替数组处理
提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的长度。
而向量类java.util.Vector可以根据需要动态伸缩。

创建Vector对象：Vector v=new Vector();<br />    给向量添加元素：v.addElement(Object obj);   //obj必须是对象<br />    取出向量中的元素：Object  obj=v.elementAt(0);<br />    注意第一个元素的下标是0，返回值是Object类型的。<br />    计算向量的长度：v.size();

public class ScoreTest {
    public static void main(String[] args) {
        //1.实例化Scanner，用于从键盘获取学生成绩
        Scanner scan = new Scanner(System.in);
        //2.创建Vector对象：Vector v=new Vector();相当于原来的数组
        Vector v = new Vector();
        //3.通过for(;;)或while(true)方式，给Vector中添加数组
        int maxScore = 0;
        for(;;){
            System.out.println("请输入学生成绩（以负数代表输入结束）");
            int score = scan.nextInt();
            //3.2 当输入是负数时，跳出循环
            if(score < 0){
                break;
            }
            if(score > 100){
                System.out.println("输入的数据非法，请重新输入");
                continue;
            }
            //3.1 添加操作：：v.addElement(Object obj)
            //jdk5.0之前：
//            Integer inScore = new Integer(score);
//            v.addElement(inScore);//多态
            //jdk5.0之后：
            v.addElement(score);//自动装箱
            //4.获取学生成绩的最大值
            if(maxScore < score){
                maxScore = score;
            }
        }
        //5.遍历Vector，得到每个学生的成绩，并与最大成绩比较，得到每个学生的等级。
        char level;
        for(int i = 0;i < v.size();i++){
            Object obj = v.elementAt(i);
            //jdk 5.0之前：
//            Integer inScore = (Integer)obj;
//            int score = inScore.intValue();
            //jdk 5.0之后：
            int score = (int)obj;
            if(maxScore - score <= 10){
                level = 'A';
            }else if(maxScore - score <= 20){
                level = 'B';
            }else if(maxScore - score <= 30){
                level = 'C';
            }else{
                level = 'D';
            }
            System.out.println("student-" + i + " score is " + score + ",level is " + level);
        }
    }
}