• JAVA基础（十一）

    向下转型

    有了对象的多态性以后，内存上实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法，子类特有的属性和方法不能调用。

    如何才能调用子类特有的属性和方法？

    向下转型：使用强制类型转换符

    注：此处完整代码见JAVA基础（十）

    1. Person p1 = new Man();
    2. Man m1 = (Man)p1;

     使用强转时，可能出现ClassCastException的异常

    1. Person p1 = new Man();
    2. Woman m1 = (Woman )p1;
    3. m1.goShoping();    //异常

    因为内存中没有Woman的属性和方法

    instanceof 操作符

    x instanceof A：检验x是否为类A的实例，返回值为boolean型

            要求x所属的类与类A必须是子类和父类的关系，否则编译错误。

            如果x属于类A的子类B，x instanceof A值也为true。

    1. 		if (p1 instanceof Person) {
    2. 			System.out.println("____Person____");
    3. 		} 
    4. 		
    5. 		if (p1 instanceof Object) {
    6. 			System.out.println("____Object____");
    7. 		}

    为了避免在向下转型时出现异常，我们在向下转型前，先进行instanceof的判断，一旦返回true，就进行向下转型，否则就不执行向下转型

    1.         if (p1 instanceof Woman) {
    2. 			System.out.println("____Woman____");
    3. 			Woman w2 = (Woman)p1;
    4. 			w2.goShopping();
    5. 		} 
    6. 		
    7. 		if (p1 instanceof Man) {
    8. 			System.out.println("____Man____");
    9. 			Man m2 = (Man)p1;
    10. 			m2.earnMoney();
    11. 		}

    测试代码

    1. package com.xxx.java;
    2.  
    3. public class PersonTest {
    4. 	public static void main(String[] args) {
    5. 		Person p = new Person();
    6. 		p.eat();
    7. 		
    8. 		Man m = new Man();
    9. 		m.eat();
    10. 		m.age = 25;
    11. 		m.earnMoney();
    12. 		
    13. 		System.out.println("*******************");
    14. 		//多态性
    15. 		Person p1 = new Man();
    16. 		
    17. 		Person p2 = new Woman();
    18. 		
    19. 		p1.eat();	//执行子类重写的方法
    20. 		p1.walk();
    21. 		System.out.println(p1.id);		
    22. 		//p1.earnMoney();
    23. 		System.out.println("**********************");
    24. 		
    25. 		//Man m1 = (Man)p1;
    26. 		//m1.earnMoney();
    27. 		//m1.isSomking = true;
    28. 		
    29. 		//Woman w1 = (Woman)p1;
    30. 		//w1.goShopping();
    31. 		
    32. 		if (p1 instanceof Woman) {
    33. 			System.out.println("____Woman____");
    34. 			Woman w2 = (Woman)p1;
    35. 			w2.goShopping();
    36. 		} 
    37. 		
    38. 		if (p1 instanceof Man) {
    39. 			System.out.println("____Man____");
    40. 			Man m2 = (Man)p1;
    41. 			m2.earnMoney();
    42. 		} 
    43. 		
    44. 		if (p1 instanceof Person) {
    45. 			System.out.println("____Person____");
    46. 		} 
    47. 		
    48. 		if (p1 instanceof Object) {
    49. 			System.out.println("____Object____");
    50. 		} 
    51. 		
    52. 		//练习：编译通过，运行不通过：
    53. 		//Person p3 = new Person();
    54. 		//Man m3 = (Man)p3;
    55. 		
    56. 		//编译通过，运行通过
    57. 		Object obj = new Woman();
    58. 		Person p4 =(Person)obj;
    59. 		
    60. 		//编译不通过
    61. 		//Man m5 = new Woman();
    62. 	}
    63. }

    练习

    1. package com.xxx.exer;
    2.  
    3. public class FieldMethodTest {
    4. 	public static void main(String[] args) {
    5. 		Sub s = new Sub();
    6. 		System.out.println(s.count);	//20
    7. 		s.display();		//20
    8. 		
    9. 		//多态性
    10. 		Base b = s;
    11. 		System.out.println(b == s);		//true
    12. 		System.out.println(b.count);	//10
    13. 		//虚拟方法调用
    14. 		b.display();	//20
    15. 	}
    16. }
    17.  
    18. class Base {
    19. 	int count = 10;
    20.  
    21. 	public void display() {
    22. 		System.out.println(this.count);
    23. 	}
    24. }
    25.  
    26. class Sub extends Base {
    27. 	int count = 20;
    28.  
    29. 	public void display() {
    30. 		System.out.println(this.count);
    31. 	}
    32. }

    子类继承父类 

            若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统              将不可能把父类里的方法转移到子类中。

            对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实            例变量依然不可能覆盖父类中定义的实例变量

    练习2

    1. class Person {
    2.     protected String name="person";
    3.     protected int age=50;
    4.  
    5.     public String getInfo() {
    6.          return "Name: "+ name + "\n" +"age: "+ age;
    7.      }
    8. }
    9.  
    10. class Student extends Person {
    11.     protected String school="pku";
    12.  
    13.     public String getInfo() {
    14.         return "Name: "+ name + "\nage: "+ age + "\nschool: "+ school;
    15.     }
    16. }
    17.  
    18. class Graduate extends Student{
    19.     public String major="IT";
    20.  
    21.     public String getInfo() {
    22.         return "Name: "+ name + "\nage: "+ age + "\nschool: "+ 
    23.                 school+"\nmajor:"+major;
    24.     }
    25. }

    建立InstanceTest 类，在类中定义方法 method(Person e);

    在method中:

            (1)根据e的类型调用相应类的getInfo()方法。

            (2)根据e的类型执行：

                    如果e为Person类的对象，输出：  “a person”;

                    如果e为Student类的对象，输出： “a student”

                                                                           “a person ”

                     如果e为Graduate类的对象，输出： “a graduated student”

                                                                               “a student”

                                                                              “a person”

    1. package com.xxx.exer;
    2.  
    3. public class InstanceTest {
    4. 	public static void main(String[] args) {
    5. 		InstanceTest test = new InstanceTest();
    6. 		test.methed(new Person());
    7. 	}
    8.  
    9. 	public void methed(Person e) {
    10. 		System.out.println(e.getInfo());
    11.  
    12. 		if (e instanceof Graduate) {
    13. 			System.out.println("“a graduated student”");
    14. 		}
    15. 		if (e instanceof Student) {
    16. 			System.out.println("“a student”");
    17. 		}
    18. 		System.out.println("“a person”");
    19. 	}
    20. }

    定义三个类，父类GeometricObject代表几何形状，子类Circle代表圆形，MyRectangle代表矩形。定义一个测试类GeometricTest，编写equalsArea方法测试两个对象的面积是否相等（注意方法的参 数类型，利用动态绑定技术），编写displayGeometricObject方法显示对象的面积（注意方法的参 数类型，利用动态绑定技术）。

    1. package com.xxx.exer1;
    2.  
    3. public class GeometricObject {
    4. 	protected String color;
    5. 	protected double weight;
    6. 	
    7. 	public GeometricObject(String color, double weight) {
    8. 		super();
    9. 		this.color = color;
    10. 		this.weight = weight;
    11. 	}
    12. 	
    13. 	public String getColor() {
    14. 		return color;
    15. 	}
    16. 	public void setColor(String color) {
    17. 		this.color = color;
    18. 	}
    19. 	public double getWeight() {
    20. 		return weight;
    21. 	}
    22. 	public void setWeight(double weight) {
    23. 		this.weight = weight;
    24. 	}
    25. 	
    26. 	public double findArea() {
    27. 		return 0.0;
    28. 	}
    29. }
    1. package com.xxx.exer1;
    2.  
    3. public class Circle extends GeometricObject {
    4. 	private double radius;
    5.  
    6. 	public Circle(String color, double weight, double radius) {
    7. 		super(color, weight);
    8. 		this.radius = radius;
    9. 	}
    10.  
    11. 	public double getRadius() {
    12. 		return radius;
    13. 	}
    14.  
    15. 	public void setRadius(double radius) {
    16. 		this.radius = radius;
    17. 	}
    18. 	
    19. 	@Override
    20. 	public double findArea() {
    21. 		return 3.14 * radius * radius;
    22. 	}
    23. }
    1. package com.xxx.exer1;
    2.  
    3. public class MyRectangle extends GeometricObject{
    4. 	private double width;
    5. 	private double height;
    6. 	
    7. 	public MyRectangle(String color, double weight, double width, double height) {
    8. 		super(color, weight);
    9. 		this.width = width;
    10. 		this.height = height;
    11. 	}
    12.  
    13. 	public double getWidth() {
    14. 		return width;
    15. 	}
    16.  
    17. 	public void setWidth(double width) {
    18. 		this.width = width;
    19. 	}
    20.  
    21. 	public double getHeight() {
    22. 		return height;
    23. 	}
    24.  
    25. 	public void setHeight(double height) {
    26. 		this.height = height;
    27. 	}
    28. 	
    29. 	@Override
    30. 	public double findArea() {
    31. 		return width * height;
    32. 	}
    33. }

    测试

    1. package com.xxx.exer1;
    2.  
    3. public class GeometricTest {
    4. 	
    5. 	public static void main(String[] args) {
    6. 		GeometricTest test = new GeometricTest();
    7. 		
    8. 		Circle c1 = new Circle("white",1.0,2.3);
    9. 		test.displayGeometricObject(c1);
    10. 		
    11. 		Circle c2 = new Circle("white",1.0,3.3);
    12. 		test.displayGeometricObject(c2);
    13.  
    14. 		System.out.println("c1和c2的面积是否相等：" + test.equalsArea(c1, c2));
    15. 		
    16. 		MyRectangle m1 = new MyRectangle("black",2.0,2.1,3.4);
    17. 		test.displayGeometricObject(m1);
    18. 	}
    19. 	
    20. 	public boolean equalsArea(GeometricObject o1,GeometricObject o2) {
    21. 		return o1.findArea() == o2.findArea();
    22. 	}
    23. 	
    24. 	public void displayGeometricObject(GeometricObject o) {
    25. 		System.out.println("面积为：" + o.findArea());
    26. 	}
    27. }

    多态是编译时行为还是运行时行为？ 如何证明？

    1. package com.xxx.exer1;
    2.  
    3. import java.util.Random;
    4.  
    5. //面试题：多态是编译时行为还是运行时行为？
    6. //证明如下：
    7. class Animal  {
    8.  
    9. 	protected void eat() {
    10. 		System.out.println("animal eat food");
    11. 	}
    12. }
    13.  
    14. class Cat  extends Animal  {
    15.  
    16. 	protected void eat() {
    17. 		System.out.println("cat eat fish");
    18. 	}
    19. }
    20.  
    21. class Dog  extends Animal  {
    22.  
    23. 	public void eat() {
    24. 		System.out.println("Dog eat bone");
    25.  
    26. 	}
    27.  
    28. }
    29.  
    30. class Sheep  extends Animal  {
    31.  
    32.  
    33. 	public void eat() {
    34. 		System.out.println("Sheep eat grass");
    35.  
    36. 	}
    37.  
    38.  
    39. }
    40.  
    41. public class InterviewTest {
    42.  
    43. 	public static Animal  getInstance(int key) {
    44. 		switch (key) {
    45. 		case 0:
    46. 			return new Cat ();
    47. 		case 1:
    48. 			return new Dog ();
    49. 		default:
    50. 			return new Sheep ();
    51. 		}
    52.  
    53. 	}
    54.  
    55. 	public static void main(String[] args) {
    56. 		int key = new Random().nextInt(3);
    57.  
    58. 		System.out.println(key);
    59.  
    60. 		Animal  animal = getInstance(key);
    61. 		
    62. 		animal.eat();
    63. 		 
    64. 	}
    65.  
    66. }

    拓展问题：

    1. package com.xxx.exer1;
    2. //考查多态的笔试题目：
    3. public class InterviewTest1 {
    4.  
    5. 	public static void main(String[] args) {
    6. 		Base base = new Sub();
    7. 		base.add(1, 2, 3);
    8.  
    9. //		Sub s = (Sub)base;
    10. //		s.add(1,2,3);
    11. 	}
    12. }
    13.  
    14. class Base {
    15. 	public void add(int a, int... arr) {
    16. 		System.out.println("base");
    17. 	}
    18. }
    19.  
    20. class Sub extends Base {
    21.  
    22. 	public void add(int a, int[] arr) {
    23. 		System.out.println("sub_1");
    24. 	}
    25.  
    26. //	public void add(int a, int b, int c) {
    27. //		System.out.println("sub_2");
    28. //	}
    29.  
    30. }

    Object类的使用

    Object类是所有Java类的根父类

    如果在类的声明中未使用extends关键字指明其父类，则默认父类 为java.lang.Object类

    无属性，只有一个空参构造器

    常用方法：equals () 、toString () 、getClass () 、hashCode () 、clone () 、finalize () 、wait () 、

    notify () 、notifyAll

    ==操作符与equals方法

    = =：

            基本类型比较值:只要两个变量的值相等，即为true。

            引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。

    用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则会报错

    equals()：

            所有类都继承了Object，也就获得了equals()方法。还可以重写。 

                    只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。

            源码：

    1.     public boolean equals(Object obj) {
    2.         return (this == obj);
    3.     }

            特例：当用equals()方法进行比较时，对类File、String、Date及包装类 （Wrapper Class ）                     来说，是比较类型及内容而不考虑引用的是否是同一个对象

            原因：在这些类中重写了Object类的equals()方法

    1.         //比较基本数据类型
    2. 		int i = 10;
    3. 		int j = 10;
    4. 		double d = 10.0;	
    5. 		System.out.println(i == j);	//true
    6. 		System.out.println(i == d);	//true
    7. 		
    8. 		boolean b = true;
    9. 		//System.out.println(i == b);	报错
    10. 		
    11. 		char c = 10;
    12. 		System.out.println(i == c);	//true
    13. 		
    14. 		char c1 = 'A';
    15. 		char c2 = 65;
    16. 		System.out.println(c1 == c2);
    17. 		
    18. 		//比较引用数据类型
    19. 		Customer cust1 = new Customer("Tom",21);
    20. 		Customer cust2 = new Customer("Tom",21);
    21. 		System.out.println(cust1 == cust2);
    22. 		
    23. 		String str1 = new String("abc");
    24. 		String str2 = new String("abc");
    25. 		System.out.println(str1 == str2);
    26. 		
    27. 		System.out.println("*************************");
    28. 		
    29. 		//equals的使用
    30. 		System.out.println(cust1.equals(cust2));
    31. 		System.out.println(str1.equals(str2)); //String重写了

    重写equals方法

    1. @Override
    2.     //比较两个对象的name和age是否相同
    3. 	public boolean equals(Object obj) {
    4. 		if (this == obj) {
    5. 			return true;
    6. 		}
    7. 		if (obj instanceof Customer) {
    8. 			Customer cust = (Customer) obj;
    9. 			return this.age == cust.age && this.name.equals(cust);
    10.  
    11. 		}
    12. 		return false;
    13.  
    14. 	}

    也可以使用Eclipse提供的一键生成equals方法

    1. 	//自动生成的equals
    2. 	@Override
    3. 	public boolean equals(Object obj) {
    4. 		if (this == obj)
    5. 			return true;
    6. 		if (obj == null)
    7. 			return false;
    8. 		if (getClass() != obj.getClass())
    9. 			return false;
    10. 		Customer other = (Customer) obj;
    11. 		return age == other.age && Objects.equals(name, other.name);
    12. 	}

    重写equals()方法的原则

    对称性：如果x.equals(y)返回是“true” ，那么y.equals(x)也应该返回是 “true”。

    自反性：x.equals(x)必须返回是“true”。

    传递性：如果x.equals(y)返回是“true” ，而且y.equals(z)返回是“true” ， 那么z.equals(x)也应该                    返回是“true”。

    一致性：如果x.equals(y)返回是“true” ，只要x和y内容一直不变，不管你 重复x.equals(y)多少次，                返回都是“true”。

    任何情况下，x.equals(null)，永远返回是“false” ；

    x.equals(和x不同类型的对象)永远返回是“false”。

    ==和equals的区别

    == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型 就是比较内存地址

    equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也 是

    ==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中 用的比较多，久而久之，形成了equals是比较值的错误观点。

    具体要看自定义类里有没有重写Object的equals方法来判断。

    通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

    toString() 方法

    toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。

    当我们输出一个对象的引用时，实际上就是调用当前对象的toString（）

            因为print方法若输出一个对象会调用valueOf方法，而valueOf方法只要该对象不为空就调用             toString方法

    Object类中的源码

    1.     public String toString() {
    2.         return getClass().getName() + "@" + Integer.toHexString(hashCode());
    3.     }

    像String Date File 包装类 等 都重写了Object类的toString方法

    自定义类也可以重写toString方法

    1.     public String toString() {
    2. 		return "Customer[name = " + name + " age = " + age + "]";
    3. 	}

    也可以自动生成：

    1. 	@Override
    2. 	public String toString() {
    3. 		return "Customer [name=" + name + ", age=" + age + "]";
    4. 	}

    测试 

    1. 		Customer cust1 = new Customer("Tom",21);
    2. 		System.out.println(cust1.toString());//输出地址值
    3. 		System.out.println(cust1);	//输出地址值
    4. 		
    5. 		String str = new String("MM");
    6. 		System.out.println(str);

    练习

    定义两个类，父类GeometricObject代表几何形状，子类Circle代表圆形。

     写一个测试类，创建两个Circle对象，判断其颜色是否相等；利用equals方法判断其半径是否     相等；利用 toString()方法输出其半径。

    1. package com.xxx.exer3;
    2.  
    3. public class GeometricObject {
    4. 	protected String color;
    5. 	protected double weight;
    6. 	
    7. 	public GeometricObject() {
    8. 		super();
    9. 		this.color = "white";
    10. 		this.weight = 1.0;
    11. 	}
    12.  
    13. 	public GeometricObject(String color, double weight) {
    14. 		super();
    15. 		this.color = color;
    16. 		this.weight = weight;
    17. 	}
    18.  
    19. 	public String getColor() {
    20. 		return color;
    21. 	}
    22.  
    23. 	public void setColor(String color) {
    24. 		this.color = color;
    25. 	}
    26.  
    27. 	public double getWeight() {
    28. 		return weight;
    29. 	}
    30.  
    31. 	public void setWeight(double weight) {
    32. 		this.weight = weight;
    33. 	}
    34. 	
    35. 	
    36. }
    1. package com.xxx.exer3;
    2.  
    3. public class Circle extends GeometricObject {
    4. 	private double radius;
    5.  
    6. 	public Circle() {
    7. 		super();
    8. 		radius = 1.0;
    9. 	}
    10.  
    11. 	public Circle(double radius) {
    12. 		super();
    13. 		this.radius = radius;
    14. 	}
    15. 	
    16.  
    17. 	public Circle(double radius,String color,double weight) {
    18. 		super(color,weight);
    19. 		this.radius = radius;
    20. 	}
    21.  
    22. 	public double getRadius() {
    23. 		return radius;
    24. 	}
    25.  
    26. 	public void setRadius(double radius) {
    27. 		this.radius = radius;
    28. 	}
    29. 	
    30. 	public double findArea() {
    31. 		return 3.14 * radius * radius;
    32. 	}
    33. 	
    34. 	@Override
    35. 	public boolean equals(Object obj) {
    36. 		if(this == obj) {
    37. 			return true;
    38. 		}
    39. 		if(obj instanceof Circle) {
    40. 			Circle c = (Circle)obj;
    41. 			return this.radius == c.radius;
    42. 		}
    43. 		return false;
    44. 	}
    45.  
    46. 	@Override
    47. 	public String toString() {
    48. 		return "Circle [radius=" + radius + "]";
    49. 	}
    50. 	
    51. 	
    52. }
    1. package com.xxx.exer3;
    2.  
    3. public class CircleTest {
    4. 	public static void main(String[] args) {
    5. 		Circle c1 = new Circle(2.3);
    6. 		Circle c2 = new Circle(2.3, "white", 2.0);
    7. 		
    8. 		System.out.println("颜色是否相同：" + c1.getColor().equals(c2.getColor()));
    9. 		
    10. 		System.out.println("半径是否相同：" + c1.equals(c2));
    11. 		
    12. 		System.out.println(c1);	//调用toString方法
    13. 		System.out.println(c2.toString());
    14. 	}
    15. }

    单元测试（JUnit）

    使用方法：

    1、右键当前项目文件夹——Build Path——Add Libraries

     选择JUnit——Next

     选择JUnit4——Finish

    2、创建一个Java类进行单元测试 

    要求：

            此时的Java类要求是Public的；

            此类提供Public的无参构造器

    3、此类中声明一个单元测试方法：

    要求：

            此方法权限是public的

            没有返回值

            没有形参

    4、此单元测试方法上需要声明注解：@Test，并导入相关java包：org.junit.Test

    5、声明号单元测试方法以后，就能在方法体内测试相关代码

    6、写完代码以后，左键双击方法名，右键run as JUnitTest

     如果执行结果没有任何异常，为绿条

     如果执行结果出现异常，红条

    测试

    1. package com.xxx.java2;
    2.  
    3. import java.sql.Date;
    4.  
    5. import org.junit.Test;
    6.  
    7. public class JUnitTest {
    8. 	int num;
    9. 	
    10. 	public void show() {
    11. 		num = 20;
    12. 		System.out.println("show()");
    13. 	}
    14. 	
    15. 	@Test
    16. 	public void testEquals() {
    17. 		String s1 = "A";
    18. 		String s2 = "A";
    19. 		System.out.println(s1.equals(s2));
    20. 		
    21. 		Object obj = new String();
    22. 		Date date = (Date)obj;
    23. 		
    24. 		System.out.println(num);
    25. 		show();
    26. 	}
    27. 	
    28. 	@Test
    29. 	public void testToString() {
    30. 		String s2 = "A";
    31. 		System.out.println(s2.toString());
    32. 	}
    33. }

    包装类(Wrapper)的使用

    针对八种基本数据类型定义相应的引用类型—包装类（封装类）

    有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

    基本数据类型包装成包装类的实例——装箱

    通过包装类的构造器实现：

    1. int i = 500; 
    2. Integer t = new Integer(i);

     还可以通过字符串参数构造包装类对象：

    1. Float f = new Float(“4.56”);
    2. Long l = new Long(“asdf”); //NumberFormatException

    获得包装类对象中包装的基本类型变量 ---拆箱

    调用包装类的.xxxValue()方法：

    1.         Integer in1 = new Integer(12);
    2. 		int i1 = in1.intValue();
    3. 		System.out.println(i1 + 1);

    JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

    1.         //自动装箱：
    2. 		int num2 = 10;
    3. 		Integer in1 = num2;
    1.         //自动拆箱
    2. 		int num3 = in1;

    包装类转换成字符串与基本数据类型转换成字符串

    1.         float f1 = 12.3f;
    2. 		String str2 = String.valueOf(f1);
    3.  
    4. 		Double d1 = new Double(12.4);
    5. 		String str3 = String.valueOf(d1);

    除此之外基本数据类型还可以通过字符串拼接来转换

    1.         int num1 = 10;
    2. 		String str1 = num1 + "";

    字符串转换成基本数据类型

    通过包装类的构造器实现：

    1. String str = "123"
    2. int i = new Integer(str);

    通过包装类的parseXxx(String s)静态方法：

    1.         String str2 = "true";
    2. 		boolean b1 = Boolean.parseBoolean(str2);
    3. 		System.out.println(b1);

    相关代码

    1. package com.xxx.java2;
    2.  
    3. import org.junit.Test;
    4.  
    5. public class WrapperTest {
    6. 	@Test
    7. 	public void test1() {
    8. 		// 基本数据类型——>包装类：
    9. 		int num = 10;
    10. 		Integer in1 = new Integer(num); // 传入int
    11. 		System.out.println(in1.toString());
    12.  
    13. 		Integer in2 = new Integer("123"); // 传入String
    14. 		System.out.println(in2.toString());
    15.  
    16. 		// 报异常
    17. 		// Integer in3 = new Integer("123abc"); //不能传入非数字
    18. 		// System.out.println(in3.toString());
    19.  
    20. 		Float f1 = new Float(12.3f); // 传入float
    21. 		Float f2 = new Float(12.3f); // 传入double
    22. 		Float f3 = new Float("12.3"); // 传入String
    23. 		System.out.println(f1);
    24. 		System.out.println(f2);
    25. 		System.out.println(f3);
    26.  
    27. 		Boolean b1 = new Boolean(true);
    28. 		Boolean b2 = new Boolean("true");
    29.  
    30. 		// 不会报错
    31. 		Boolean b3 = new Boolean("tRuE");
    32. 		Boolean b4 = new Boolean("true123"); // 只有传入的字符串不是ture（忽略大小写都为false）
    33.  
    34. 		Order order = new Order();
    35. 		System.out.println(order.isMale); // false
    36. 		System.out.println(order.isFemale); // null
    37. 	}
    38.  
    39. 	// 包装类转换为基本数据类型
    40. 	@Test
    41. 	public void test2() {
    42. 		Integer in1 = new Integer(12);
    43. 		int i1 = in1.intValue();
    44. 		System.out.println(i1 + 1);
    45.  
    46. 		Float f1 = new Float(12.3);
    47. 		float f2 = f1.floatValue();
    48. 		System.out.println(f2 + 1);
    49. 	}
    50.  
    51. 	@Test
    52. 	public void test3() {
    53. 		// 包装类的使用
    54. 		int num1 = 10;
    55. 		// Integer in = new Integer(num1);
    56. 		// method(in);
    57. 		// JDK5.0新增自动装箱与拆箱
    58. 		method(num1);
    59.  
    60. 		// 自动装箱：
    61. 		int num2 = 10;
    62. 		Integer in1 = num2;
    63.  
    64. 		boolean b1 = true;
    65. 		Boolean b2 = b1;
    66.  
    67. 		// 自动拆箱
    68. 		System.out.println(in1.toString());
    69. 		int num3 = in1;
    70. 	}
    71.  
    72. 	public void method(Object obj) {
    73. 		System.out.println(obj);
    74. 	}
    75.  
    76. 	@Test
    77. 	public void test4() {
    78. 		// 基本数据类型、包装类——>String类型
    79. 		// 方式1：
    80. 		int num1 = 10;
    81. 		String str1 = num1 + "";
    82. 		// 方式2：
    83. 		float f1 = 12.3f;
    84. 		String str2 = String.valueOf(f1);
    85.  
    86. 		Double d1 = new Double(12.4);
    87. 		String str3 = String.valueOf(d1);
    88. 		System.out.println(str2);
    89. 		System.out.println(str3);
    90. 	}
    91.  
    92. 	@Test
    93. 	public void test5() {
    94. 		// String类型——>基本数据类型、包装类
    95. 		String str1 = "123";
    96. 		
    97. 		//错误情况
    98. 		//int num1 = (int)str1;
    99. 		//Integer in = (Integer)str1; 
    100. 		
    101. 		//调用包装类的parsexxx方法
    102. 		int num2 = Integer.parseInt(str1);
    103. 		System.out.println(num2 + 1);
    104. 		
    105. 		String str2 = "true";
    106. 		boolean b1 = Boolean.parseBoolean(str2);
    107. 		System.out.println(b1);
    108. 	}
    109. }
    110.  
    111. class Order {
    112. 	boolean isMale;
    113. 	Boolean isFemale;
    114. }

     总结：基本类型、包装类与String类间的转换

    面试题

    1

    1.         Object o1 = true ? new Integer(1) : new Double(2.0);
    2. 		System.out.println(o1);    //1.0

    解析：

            三元运算符自动类型转换

            多态虚拟方法调用

    2

    1.         Object o2;
    2. 		if (true)
    3. 		    o2 = new Integer(1);
    4. 		else
    5. 		    o2 = new Double(2.0);
    6. 		System.out.println(o2);    //1

    3

    1.         Integer i = new Integer(1);
    2. 		Integer j = new Integer(1);
    3. 		System.out.println(i == j);//false
    4. 		
    5. 		Integer m = 1;
    6. 		Integer n = 1;
    7. 		System.out.println(m == n);//true
    8. 		
    9. 		Integer x = 128;
    10. 		Integer y = 128;
    11. 		System.out.println(x == y);//false

    解析：

            -128到127为常用数，在Integer内定义了一个IntegerCathe，里面定义了一个Intefer[ ]，保              存了这个范围的整数，如有需要使用该数组的元素,不需要new，提高了效率，所以m == n

            而128不在这个范围，需要在new一个新的对象，地址不同自然返回false

    练习：

    利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出 最高分，并输出学生成绩等级。

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

            创建Vector对象：Vector v=new Vector();

            给向量添加元素：v.addElement(Object obj); //obj必须是对象

            取出向量中的元素：Object obj=v.elementAt(0);

                    注意第一个元素的下标是0，返回值是Object类型的。

            计算向量的长度：v.size();

            若与最高分相差10分内：A等；20分内：B等； 30分内：C等；其它：D等

    1. package com.xxx.exer4;
    2.  
    3. import java.util.Scanner;
    4. import java.util.Vector;
    5.  
    6. public class ScoreTest {
    7. 	public static void main(String[] args) {
    8. 		Scanner scan = new Scanner(System.in);
    9.  
    10. 		Vector v = new Vector();
    11. 		int maxScore = 0;
    12. 		for (;;) {
    13. 			System.out.println("请输入学生成绩（以负数代表输入结束）");
    14. 			int score = scan.nextInt();
    15. 			if (score < 0) {
    16. 				break;
    17. 			}
    18. 			if (score > 100) {
    19. 				System.out.println("输入的数据非法,请重新输入");
    20. 				continue;
    21. 			}
    22. 			v.addElement(score);
    23. 			if (maxScore < score) {
    24. 				maxScore = score;
    25. 			}
    26. 		}
    27. 		char level;
    28. 		for (int i = 0; i < v.size(); i++) {
    29. 			Object obj = v.elementAt(i);
    30. 			
    31. 			int score = (int)obj;
    32. 			if (maxScore - score <= 10) {
    33. 				level = 'A';
    34. 			} else if(maxScore - score <= 20){
    35. 				level = 'B';
    36. 			}else if(maxScore - score <= 30){
    37. 				level = 'C';
    38. 			}else {
    39. 				level = 'D';
    40. 			}
    41. 			
    42. 			System.out.println("student——" + i + ",score is " + score + ",level is " + level);
    43. 		}
    44. 	}
    45. }

  • 相关阅读:
    四面阿里巴巴回来分享面经总结，定级P7架构师
    构建高可用性的 SQL Server：Docker 容器下的主从同步实现
    Java中string、int、char之间互相转换
    KiB、MiB与KB、MB的区别
    【GIT】：一文快速了解什么是GIT
    【数据分享】《中国法律年鉴》1987-2022
    python实操-----图书管理系统
    MYSQL基础——函数
    【华为校招】【校招】【Java】污染水域（DFS）
    VSCode中配置C/C++环境
  • 原文地址：https://blog.csdn.net/m0_56413004/article/details/126112919