第4章面向对象编程-2

最新推荐文章于 2023-01-17 13:30:26 发布

weixin_33737774

最新推荐文章于 2023-01-17 13:30:26 发布

阅读量2.3k

点赞数 1

文章标签： java python

原文链接：https://my.oschina.net/mondayer/blog/3025453

版权

2019独角兽企业重金招聘Python工程师标准>>>

4.1 面向对象特征之二：继承

为描述和处理个人信息，定义类Person：

public class Person {
      public String name;
      public int age;
      public Date birthDate;
      public String getInfo(){...} 
}

为描述和处理学生信息，定义类Student：

public class Student {
      public String name;
      public int age;
      public Date birthDate;
      public String school;
      public String getInfo(){...}  
}

通过继承，简化Student类的定义：

public class Person {
      public String name;
      public int age;
      public Date birthDate;
      public String getInfo() {...}
}
//Student类继承了父类Person的所有属性和方法并增加了一个属性school。
//Person中的属性和方法，Student都可以利用。
public class Student extends Person{
      public String school;
}

为什么要有继承？

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

此处的多个类称为子类，单独的这个类称为父类（基类或超类）。

类继承语法规则:

class Subclass extends Superclass{ }

继承的作用：

继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
不要仅为了获取其他类中某个功能而去继承。

关于继承的说明：

子类继承了父类，就继承了父类的方法和属性。
在子类中，可使用父类中定义的方法和属性，也可创建新的数据和方法。
在Java中，继承的关键字用的是extends，即子类不是父类的子集而是对父类的扩展。

关于继承的规则：

子类不能直接访问父类中私有的(private)的成员变量和方法。

单继承举例

Java 只支持单继承，不允许多重继承。

一个子类只能有一个父类
一个父类可以派生出多个子类

class SubDemo extends Demo{ }   //ok
class SubDemo extends Demo1,Demo2{ } //error

练习

(1)定义一个ManKind类，包括成员变量int sex和int salary；
方法void manOrWorman()：根据sex的值显示“man”(sex==1)或者“women”(sex==0)；方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。
(2)定义类Kids继承ManKind，并包括成员变量int yearsOld；方法printAge()打印yearsOld的值。
(3)在Kids类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法。

class ManKind {
    int sex;
    int salary;

    void manOrWorman() {
        if (sex == 1) {
            System.out.println("man");
        } else if (sex == 0) {
            System.out.println("women");
        }
    }

    void employeed() {
        if (salary == 0) {
            System.out.println("no job");
        } else {
            System.out.println("job");
        }
    }
}

class Kids extends ManKind {
    int yearsOld;

    void printAge() {
        System.out.println(yearsOld);
    }

    public static void main(String[] args) {
        Kids someKid = new Kids();
        someKid.sex = 1;
        someKid.salary = 1;
        someKid.yearsOld = 12;
        someKid.manOrWorman();
        someKid.employeed();
        someKid.printAge();
    }
}

练习

定义一个学生类Student，它继承自Person类。

class Person {
    String name;
    String sex;
    int age;

    public Person(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}

class Student extends Person {
    long number;
    int math;
    int english;
    int computer;

    public Student(String n, String s, int a, 
                    long k, int m, int e, int c) {
        super(n, s, a);
        number = k;
        math = m;
        english = e;
        computer = c;
    }

    double aver() {
        return (math + english + computer) / 3;
    }

    int max() {
        int max = math > english ? math : english;
        max = max > computer ? max : computer;
        return max;
    }

    int min() {
        int min = math < english ? math : english;
        min = min < computer ? min : computer;
        return min;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", number=" + number +
                ", math=" + math +
                ", english=" + english +
                ", computer=" + computer +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student("张三","男",20,101,98,88,90);
        System.out.println(stu);
    }
}

练习

根据下图实现类。在TestCylinder类中创建Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱的体积。

class Circle {
    private double radius;

    public Circle() {
        radius = 1;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public double findArea() {
        return Math.PI * radius * radius;
    }
}

class Cylinder extends Circle {
    private double length;

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double findVolume() {
        return super.findArea() * length;
    }
}

public class TestCylinder {
    public static void main(String[] args) {
        Cylinder c = new Cylinder();
        c.setRadius(2);
        System.out.println("面积是："+ c.findArea());
        c.setLength(3);
        System.out.println("体积是："+ c.findVolume());
    }
}

4.2 方法的重写(override)

定义

在子类中可以根据需要对从父类中继承来的方法进行改造，也称方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求：

重写方法必须和被重写方法具有相同的方法名、参数列表和返回值类型。
重写方法不能使用比被重写方法更严格的访问权限。
重写和被重写的方法须同时为static的，或同时为非static的。
子类方法抛出的异常不能大于父类被重写方法的异常。

重写方法举例(1)

public class Person {
    public String name;
    public int age;
    public String getInfo() {
      return "Name: "+ name + "\n" +"age: "+ age;
    }
}

public class Student extends Person {
    public String school;
    public String getInfo() {       //重写方法
      return  "Name: "+ name + "\nage: "+ age 
	  + "\nschool: "+ school;
     }
    public static void main(String args[]){
       Student s1=new Student();
       s1.name="Bob";
       s1.age=20;
       s1.school="school2";
       System.out.println(s1.getInfo());   //Name:Bob  age:20  school:school2
    }
}

Person p1=new Person();
p1.getInfo();
//调用Person类的getInfo()方法
Student s1=new Student();
s1.getInfo();
//调用Student类的getInfo()方法
这是一种“多态性”：同名的方法，用不同的对象来区分调用的是哪一个方法。

重写方法举例(2)

class Parent {
	public void method1() {}
}
class Child extends Parent {
	private void method1() {}  
	//非法，子类中的method1()的访问权限private比被覆盖方法的访问权限public弱
}
public class UseBoth {
	public static void main(String[] args) {
		Parent p1 = new Parent();
		Child p2 = new Child();
		p1.method1();
		p2.method1();
	}
}

练习

如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？(NO)

修改练习1.1中定义的类Kids，在Kids中重新定义employed()方法，覆盖父类ManKind中定义的employed()方法，输出“Kids should study and no job.”

class Kids extends ManKind {
    //...
    void employeed(){
        System.out.println("Kids should study and no job.");
    }
    //...
}

4.3 四种访问权限修饰符

Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类对象成员的访问权限。

对于class的权限修饰只可以用 public 和 default 。

public类可以在任意地方被访问。
default类只可以被同一个包内部的类访问。

访问控制举例

class Parent{
	private int f1 = 1;
	int f2 = 2;
	protected  int f3 = 3;
	public  int f4 = 4;
	private  void  fm1() {System.out.println("in fm1() f1=" + f1);}
	void fm2() {System.out.println("in fm2() f2=" + f2);}
	protected  void  fm3() {System.out.println("in fm3() f3=" + f3);}
	public void fm4() {System.out.println("in fm4() f4=" + f4);}	
}

class Child extends Parent{               //设父类和子类在同一个包内
	private int c1 = 21;
	public  int c2 = 22;	 
	private void cm1(){System.out.println("in cm1() c1=" + c1);}
	public  void cm2(){System.out.println("in cm2() c2=" + c2);}
	public static void main(String args[]){
		int i; 
		Parent  p = new Parent();		
		i = p.f2; //	i = p.f3;i = p.f4;p.fm2(); //p.fm3();	p.fm4();		
		Child  c = new Child();
		i = c.f2;	        //	i = c.f3;		i = c.f4;		
		i = c.c1;	        //	i = c.c2;		
		c.cm1();        // c.cm2();    c.fm2();   c.fm3();   c.fm4()
	}
}

访问控制分析

4.4 关键字super

在Java类中使用super来调用父类中的指定操作：

super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造方法中调用父类的构造器

注意：

尤其当子父类出现同名成员时，可以用super进行区分
super的追溯不仅限于直接父类
super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

关键字super举例

class Person {
	protected String name="张三";
        protected int age;
	public String getInfo() {
		return "Name: " + name + "\nage: " + age;
    	} 
}
class Student extends Person {
        protected String name = "李四";
	private String school = "New Oriental";
	public String getSchool(){ return school; }
    	public String getInfo() {
		return super.getInfo() +"\nschool: " +school;
    	} 
}
public class TestStudent{
	public static void main(String[] args){
		Student st = new Student();
		System.out.println(st.getInfo());
	} 
}

练习

1.修改练习1.1中定义的类Kids中employed()方法，在该方法中调用父类ManKind的employed()方法，然后再输出“but Kids should study and no job.”

class Kids extends ManKind {
    //...
    void employeed(){
        super.employeed();
	System.out.println("Kids should study and no job.");
    }
    //...

2.修改练习1.3中定义的Cylinder类，在Cylinder类中覆盖findArea()方法，计算圆柱的表面积。考虑：findVolume方法怎样做相应的修改？在TestCylinder类中创建Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱的表面积和体积。

附加题：在TestCylinder类中创建一个Circle类的对象，设置圆的半径，计算输出圆的面积。体会父类和子类成员的分别调用。

调用父类的构造器

子类中所有的构造器默认都会访问父类中空参数的构造器
当父类中没有空参数的构造器时，子类的构造器必须通过**this(参数列表)或者super(参数列表)**语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行
如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

调用父类构造器举例

public class Person {

private String name;
private int age;
private Date birthDate;	

public Person(String name, int age, Date d) {
	this.name = name;
	this.age = age;
	this.birthDate = d;
}
public Person(String name, int age) {
	this(name, age, null);
}
public Person(String name, Date d) {
	this(name, 30, d);
 }
public Person(String name) {
	this(name, 30);
}

// ……
}

public class Student extends Person {
	private String school;
        public Student(String name, int age, String s) {
	       super(name, age);
	       school = s;
        }
	public Student(String name, String s) {
	    super(name);
	    school = s;
	}
	public Student(String s) { 
// 编译出错: no super(),
// 系统将调用父类无参数的构造方法。  
	    school = s;
	}
}

this和super的区别

4.5 子类对象实例化过程

思考：

为什么super(…)和this(…)调用语句不能同时在一个构造器中出现？
为什么super(…)或this(…)调用语句只能作为构造器中的第一句出现？

class Creature{
       public Creature(){
	System.out.println("Creature无参数的构造器");	
       }
}
class Animal extends Creature{
       public Animal(String name){
	System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
       }
       public Animal(String name , int age){
	this(name);
	System.out.println("Animal带两个参数的构造器，其age为" + age);
       }
}
public class Wolf extends Animal{
       public Wolf(){
	   super("灰太狼", 3);
	   System.out.println("Wolf无参数的构造器");
       }
       public static void main(String[] args){
	   new Wolf();
       }    
}

练习

修改练习1.3中定义的Circle类和Cylinder类的构造器，利用构造器参数为对象的所有属性赋初值。

4.6 面向对象特征之三：多态

多态性，是面向对象中最重要的概念，在Java中有两种体现：

方法的重载(overload)和重写(overwrite)。
对象的多态性 ——可以直接应用在抽象类和接口上。

Java引用变量有两个类型：编译时类型和运行时类型。

编译时类型由声明该变量时使用的类型决定。
运行时类型由实际赋给该变量的对象决定。

若编译时类型和运行时类型不一致，就出现多态。

对象的多态 —在Java中，子类的对象可以替代父类的对象使用

一个变量只能有一种确定的数据类型。
一个引用类型变量可能指向(引用)多种不同类型的对象。

Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象
```	
> 子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就**不能**再访问子类中添加的属性和方法。

Student m = new Student(); m.school = "pku"; //合法,Student类有school成员变量 Person e = new Student(); e.school = "pku"; //非法,Person类没有school成员变量

//属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

### 虚拟方法调用(Virtual Method Invocation)
正常的方法调用

Person e = new Person(); e.getInfo(); Student e = new Student(); e.getInfo();

虚拟方法调用(多态情况下)

Person e = new Student(); e.getInfo(); //调用Student类的getInfo()方法

编译时类型和运行时类型

> 编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定

### 多态小结
前提：

- 需要存在继承或者实现关系
- 要有覆盖操作

成员方法：

- 编译时：要查看引用变量所属的类中是否有所调用的方法。
- 运行时：调用实际对象所属的类中的重写方法

成员变量：

- 不具备多态性，只看引用变量所属的类。

### 练习：继承成员变量和继承方法的区别

class Base{ int count = 10; public void display(){ System.out.println(this.count); } } class Sub extends Base{ int count = 20; public void display(){ System.out.println(this.count); } } public class TestFieldMethod { public static void main(String[] args) { Sub s = new Sub(); System.out.println(s.count); s.display(); Base b = s; System.out.println(b == s); System.out.println(b.count); b.display(); } }

子类继承父类

- 若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中
- 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

### 多态性应用举例
方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法。

public class Test{ public void method(Person e) { //…… e.getInfo(); } public static void main(Stirng args[]){ Test t = new Test(); Student m = new Student(); t.method(m); //子类的对象m传送给父类类型的参数e } }

### instanceof 操作符
x instanceof A：检验x是否为类A的对象，返回值为boolean型。

- 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
- 如果x属于类A的子类B，x instanceof  A值也为true。

public class Person extends Object {…} public class Student extends Person {…} public class Graduate extends Person {…}

public void method1(Person e) { if (e instanceof Person) // 处理Person类及其子类对象 if (e instanceof Student) //处理Student类及其子类对象 if (e instanceof Graduate) //处理Graduate类及其子类对象 }

### 练习
> 建立TestInstance 类，在类中定义方法method1(Person e);
在method1中:  
(1)根据e的类型调用相应类的getInfo()方法。  
(2)根据e的类型执行：  
如果e为Person类的对象，输出：“a person”;  
如果e为Student类的对象，输出  
“a student”  
“a person ”  
如果e为Graduate类的对象，输出：  
“a graduated student”  
“a student”  
“a person”

class Person { protected String name="person"; protected int age=50; public String getInfo() { return "Name: "+ name + "\n" +"age: "+ age; } } class Student extends Person { protected String school="pku"; public String getInfo() { return "Name: "+ name + "\nage: "+ age + "\nschool: "+ school; } } class Graduate extends Student{ public String major="IT"; public String getInfo() { return "Name: "+ name + "\nage: "+ age + "\nschool: "+ school+"\nmajor:"+major; } }

### 对象类型转换 (Casting)
#### 基本数据类型的Casting：
自动类型转换：小的数据类型可以自动转换成大的数据类型。如

long g=20; double d=12.0f;

强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型。如

float f=(float)12.0; int a=(int)1200L;

#### 对Java对象的强制类型转换称为造型
- 从子类到父类的类型转换可以自动进行
- 从父类到子类的类型转换必须通过造型(强制类型转换)实现
- 无继承关系的引用类型间的转换是非法的
- 在造型前可以使用instanceof操作符测试一个对象的类型

### 对象类型转换举例

public class ConversionTest{ public static void main(String[] args) { double d = 13.4; long l = (long)d; System.out.println(l); int in = 5; //boolean b = (boolean)in; Object obj = "Hello"; String objStr = (String)obj; System.out.println(objStr); Object objPri = new Integer(5); //所以下面代码运行时引发ClassCastException异常 String str = (String)objPri; } }

### 对象类型转换举例

public class Test{ public void method(Person e) { //设Person类中没有getschool() 方法 // System.out.pritnln(e.getschool()); //非法,编译时错误 if(e instanceof Student){ Student me = (Student)e; //将e强制转换为Student类型 System.out.pritnln(me.getschool()); }
} public static void main(Stirng args[]){ Test t = new Test(); Student m = new Student(); t.method(m); } }

![](https://upload-images.jianshu.io/upload_images/13516495-8b05b630d105800e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

# 4.7  Object类、包装类
- Object类是所有Java类的根父类
- 如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类

public class Person { ... } 等价于： public class Person extends Object { ... }

例：

method(Object obj){…}//可以接收任何类作为其参数 Person o=new Person();
method(o);

### Object类中的主要方法
![](https://upload-images.jianshu.io/upload_images/13516495-c663e45e88dbd32d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

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

int a=5; if(a==6){…}

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

Person p1=new Person();
Person p2=new Person(); if (p1==p2){…}

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

### 关于equals()
- 所有类都继承了Object，也就获得了equals()方法。还可以重写。
- 只能比较引用类型，其作用与“==”相同，比较是否指向同一个对象。
格式：`obj1.equals(obj2)`
- 特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象。原因：在这些类中重写了Object类的equals()方法。

### 练习

int it = 65; float fl = 65.0f; System.out.println(“65和65.0f是否相等？” + (it == fl)); //true

char ch1 = 'A'; char ch2 = 12; System.out.println("65和'A'是否相等？" + (it == ch1));//true System.out.println(“12和ch2是否相等？" + (12 == ch2));//true

String str1 = new String("hello"); String str2 = new String("hello"); System.out.println("str1和str2是否相等？"+ (str1 == str2));//false System.out.println("str1是否equals str2？"+(str1.equals(str2)));//true System.out.println(“hello” == new java.sql.Date()); //编译不通过

### 练习

Person p1 = new Person(); p1.name = "atguigu";

Person p2 = new Person(); p2.name = "atguigu";

System.out.println(p1.name .equals( p2.name));//true System.out.println(p1.name == p2.name);//true System.out.println(p1.name == "atguigu");

String s1 = new String("bcde"); String s2 = new String("bcde"); System.out.println(s1==s2);//false

![](https://upload-images.jianshu.io/upload_images/13516495-649418cb1fca6dc3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

### 练习
> 1.编写Order类，有int型的orderId，String型的OrderName，相应的getter()和setter()方法，两个参数的构造器，重写父类的equals()方法：public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。

> 2.请根据以下代码自行定义能满足需要的MyDate类,在MyDate类中覆盖equals方法，使其判断当两个MyDate类型对象的年月日都相同时，结果为true，否则为false。    public boolean equals(Object o)

class TestEquals { public static void main(String[] args) { MyDate m1 = new MyDate(14, 3, 1976); MyDate m2 = new MyDate(14, 3, 1976); if (m1 == m2) { System.out.println("m1==m2"); } else { System.out.println("m1!=m2"); //m1 != m2 } if (m1.equals(m2)) { System.out.println("m1 is equal to m2"); // m1 is equal to m2 } else { System.out.println("m1 is not equal to m2"); } } }

### toString() 方法
- toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
- 在进行String与其它类型数据的连接操作时，自动调用toString()方法。

Date now=new Date(); System.out.println(“now=”+now);
// 相当于 System.out.println(“now=”+now.toString());

- 可以根据需要在用户自定义类型中重写toString()方法
- 基本类型数据转换为String类型时，调用了对应包装类的toString()方法。

int a=10;
System.out.println(“a=”+a);

### 练习
> 定义两个类，父类GeometricObject代表几何形状，子类Circle代表圆形。

![](https://upload-images.jianshu.io/upload_images/13516495-947c43b967c0f74c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

![](https://upload-images.jianshu.io/upload_images/13516495-649c50a1dd5208e3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
> 写一个测试类，创建两个Circle对象，判断其颜色是否相等；利用equals方法判断其半径是否相等；利用toString()方法输出其半径。

### 包装类(Wrapper)
- 针对八种基本定义相应的引用类型—包装类（封装类）
- 有了类的特点，就可以调用类中的方法。
![](https://upload-images.jianshu.io/upload_images/13516495-3a0f0bfd01470ed6.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 基本数据类型包装成包装类的实例——装箱
通过包装类的构造器实现：

int i = 500;
Integer t = new Integer(i);

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

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

- 获得包装类对象中包装的基本类型变量——拆箱
调用包装类的.xxxValue()方法：

boolean b = bObj.booleanValue();

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

- 字符串转换成基本数据类型
通过包装类的构造器实现：

int i = new Integer(“12”);

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

Float f = Float.parseFloat(“12.1”);

- 基本数据类型转换成字符串
调用字符串重载的valueOf()方法：

String fstr = String.valueOf(2.34f);

更直接的方式：

String intStr = 5 + "" ;

### 包装类用法举例

int i = 500; Integer t = new Integer(i);

装箱：包装类使得一个基本数据类型的数据变成了类。
有了类的特点，可以调用类中的方法。

String s = t.toString(); // s = “500“,t是类，有toString()方法 String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。 String s2=“4.56”; double ds=Double.parseDouble(s2); //将字符串转换成数字

### 包装类的用法举例
- 拆箱：将数字包装类中内容变为基本数据类型。

int j = t.intValue(); // j = 500，intValue取出包装类中的数据

- 包装类在实际开发中用的最多的在于字符串变为基本数据类型。

String str1 = "30" ; String str2 = "30.3" ; int x = Integer.parseInt(str1) ; // 将字符串变为int型 float f = Float.parseFloat(str2) ; // 将字符串变为int型

### 练习
> 利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，并输出学生成绩等级。  
提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的长度。而向量类java.util.Vector可以根据需要动态伸缩。  
创建Vector对象：Vector v=new Vector();  
给向量添加元素：v.addElement(obj);   //obj必须是对象  
取出向量中的元素：Object  obj=v.elementAt(0);  
注意第一个元素的下标是0，返回值是Object类型的。  
计算向量的长度：v.size();  
若与最高分相差10分内：A等；20分内：B等；  
30分内：C等；其它：D等

转载于:https://my.oschina.net/mondayer/blog/3025453