java 语言程序设计-李尊朝第6章类和对象

6.1 类和对象概述

6.1.1 面向对象的基本概念

1.类：类是对对象的抽象描述。

2.对象：对象是表示现实世界中某个具体的事物；

6.1.2 类的声明　　

[修饰符] class 类名 [extends 父类名] [implements 接口名列表]

{

类成员变量声明;

类方法声明;

}

例：定义一个表示二维平面上点的类
class Point
{
   private int x,y;
   public void setPoint(int a,int b)
 {
     x=a;
     y=b;
   }
  public int getX() { return x; } 
  public int getY() { return y; }
   public String toString()   
    { return "["+x+","+y+"]"; }
}

6.1.3 对象的创建和使用

[修饰符] 类名对象名=new 类名(实参列表)；

或[修饰符] 类名对象名；

对象名=new 类名(实参列表)；

用户需要应用new完成分配空间的任务。

thePoint=new Point( );

对象的使用

引用成员变量对象名.成员变量名

引用方法对象名.方法名(参数列表)

例：定义一个表示圆形的类，能够计算圆面积和周长。
class Circle1
{
  float r;
  final double PI=3.14159;
  public double area()                    //计算面积
 {          
     return PI*r*r;
 }
  public void  setR(float x)          //设置半径
   {
      r=x;
    } 
public double  perimeter()           //计算周长
  {
     return 2*PI*r;
  }
public static void main(String args[])
 {
    double x,y;
    Circle1 cir=new Circle1();      //创建Circle1类的对象cir
    cir.setR(12.35f);         //引用cir对象的setR()方法
    x=cir.area();             //引用cir对象的area()方法
    y=cir.perimeter();        //引用cir对象的perimeter()方法
    System.out.println("圆面积="+x+"\n圆周长="+y);
  }
}

程序运行结果如下：

圆面积=479.163190376011

圆周长=77.59727539684296

6.1.4 构造方法和对象的初始化。

构造方法的特点

构造方法名与类名相同；

构造方法没有返回值；

构造方法的主要作用是对对象初始化。

构造方法不能显式地直接调用；

一个类中可以定义多个构造方法，但各构造方法的参数表不能相同，

即各构造方法的参数个数不同或参数类型不同。

class Triangle
{                               
   int x,y,z;
   public  Triangle(int i,int j,int k)          //声明构造方法
  {      
   x=i; y=j; z=k;
   }
    public static boolean judge(Triangle m)
   {
        if(Math.sqrt(m.x*m.x+ m.y*m.y)== Math.sqrt(m.z*m.z))  
               //引用Math类库的sqrt()方法
              return true;
          else
              return false;
  }
public static void main(String args[]){
    Triangle t1;               //声明Triangle类对象t1
    t1=new Triangle(3,4,5);    //实例化对象t1，调用构造方法对其进行初始化 
    if(judge(t1))            //调用judge()方法，判断t1的成员变量是
                                           //否能构成直角三角型的3个边长
        System.out.println("这是一个直角三角形");
    else
        System.out.println("这不是一个直角三角形");
   }
}

例6-4 默认构造方法的使用

class Student
{
  String name;
  String address;
  int grade;
  Student(String x1,String x2,String x3,int y) 
 { //定义构造方法
     name=x1;
    address=x2;
    grade=x3;
}
public static void main(String args[])
{  Student1 zhang;   //声明并创建zhang对象
 zhang=new Student("张三","西安市兴庆路1号",3);
  Student1 wang;   //声明并创建wang对象
  wang=new Student("王五","西安市翠华路12号",4);     
     System.out.println(zhang.name+zhang.address+zhang.grade);    System.out.println(wang.name+wang.address+wang.grade);
 }
}

缺省构造方法的使用

class Student
{
  String name;                                    //成员变量
  String address;                                 //成员变量
  int score;                                       //成员变量
  public void setMessage(String x1,String x2, int x3) //成员方法
  {    
    name=x1;
    address=x2;
    score=x3;
  }
public static void main(String args[])
 {
    Student s1=new Student();       //创建Student类对象s1
    System.out.println(s1.name+"   "+s1.address+"   
                                 "+s1.score); 
                                    //输出缺省构造方法的初始化结果
    s1.setMessage("张三","西安市兴庆路1号",75); 
                       // 调用成员方法给成员变量赋值  
    System.out.println(s1.name+"   "+s1.address+"   
                                    "+s1.score);
   }
}

程序运行结果如下：

null null 0

张三西安市兴庆路1号 75

6-5 使用无参数的构造方法

class Time
 {
  private int hour;     //0-23
  private int minute;   //0-59
  private int second;   //0-59
  public Time()
    { setTime(0,0,0); }
   public void setTime(int hh, int mm, int ss)
    {
     hour = ((hh >= 0 && hh <24) ? hh : 0);
     minute = ((mm >= 0 && mm < 60) ? mm : 0);
     second = ((ss >= 0 && ss < 60) ? ss : 0);
    }
public String toString()
   {
     return (hour + ":" + (minute < 10 ? "0" : "") + minute + 
  ":" +          (second < 10 ? "0" : "") + second );
    }
 }
public class MyTime
{
  public static void main(String args[])
  {
    Time time=new Time();
    time.setTime(11,22,33);
    System.out.println(" set time =" + time.toString());
   }
 }

运行结果如下：

set time =11:22:33

例6-6 使用多个构造方法

class Time1
{
  private int hour;              //0-23
  private int minute;            //0-59
  private int second;            //0-59
  public Time1()
   { setTime (0,0,0); }
  public Time1(int hh)
    { setTime (hh,0,0); }
  public Time1 (int hh, int mm)
    { setTime (hh,mm,0); }
  public Time1(int hh, int mm, int ss)
    { setTime (hh,mm,ss); }
public void setTime (int hh, int mm, int ss)
   {
    hour = ((hh >= 0 && hh < 24) ? hh : 0);
    minute = ((mm >= 0 && mm < 60) ? mm : 0);
    second = ((ss >= 0 && ss < 60) ? ss : 0);}

public String toString()
   {
    return (hour + ":" +(minute < 10 ? "0" : "") + minute + ":" +
            (second < 10 ? "0" : "") + second);
   }
  }
public class MyTime1
 {
  private static Time1 t0, t1, t2, t3;  
  public static void main(String args[])   
{
    t0=new Time1();
    t1=new Time1(11);
    t2=new Time1(22, 22);
    t3=new Time1(33, 33, 33);
    System.out.println(" t0= " + t0.toString());
    System.out.println("t1= " + t1.toString());
    System.out.println("t2= " + t2.toString());
    System.out.println(“t3= ” + t3.toString())；
}  }

程序运行结果如下：

t0= 0:00:00

t1= 11:00:00

t2= 22:22:00

t3= 0:33:33

6.1.5 对象销毁

通过new运算符实例化对象时，系统为对象分配所需的存储空间，存放其属性值。

但内存空间有限，不能存放无限多的对象。为此，Java提供了资源回收机制，自动销毁

无用对象，回收其所占用的存储空间。如果需要主动释放对象，或在释放对象时需要执

行特定操作，则在类中可以定义finalize()方法

    public void finalize()
   {
      方法体；
   }

6.2 类的封装
封装性是面向对象的核心特征之一。类的封装包含2层含义：将数据和对数据的操作组合起来构成类，

类是一个不可分割的独立单位；类中既要提供与外部联系的接口，同时又要尽可能隐藏类的实现细节

6.2.1 访问权限

public（公有）：被public修饰的成员变量和成员方法可以在所有类中访问。

protected（保护）：被protected修饰的成员变量和成员方法可以在声明他们的类中访问，在该类

的子类中访问，也可以在与该类位于同一包的类中访问，但不能在位于其它包的非子类中访问

private（私有）：被private修饰的成员变量和成员方法只能在声明他们的类中访问，而不能

在其他类（包括其子类）中访问

访问控制	本类	同一包中的类	其他包中子类	其他包中的类
public	Ö	Ö	Ö	Ö
private	Ö	×	×	×
protected	Ö	Ö	Ö	×
缺省	Ö	Ö	×	×

例6-7 权限修饰符的作用。

class Time
  {
  private int hour;     //0-23
  private int minute;   //0-59
  private int second;   //0-59
  public Time()
    { setTime(0,0,0); }
  public void setTime(int hh, int mm, int ss)
    {
    hour = ((hh >= 0 && hh <24) ? hh : 0);
    minute = ((mm >= 0 && mm < 60) ? mm : 0);
    second = ((ss >= 0 && ss < 60) ? ss : 0);
    }
public String toString()
{
 return (hour + ":" + (minute < 10 ? "0" : "") + minute + ":" +
            (second < 10 ? "0" : "") + second );
    }
}
public class MyTime2
  {
  public static void main(String args[])
    {
    Time time = new Time();
    time.hour = 11;        //欲将11赋给hour成员变量，但属于非法访问
    System.out.println("time" + time.toString());
    }
  }

类的访问权限

声明一个类可使用的权限修饰符只有public和缺省2种。

虽然一个Java源程序文件中可以包含多个类，但只能有一个类使用public修饰符，

的名字与源程序文件的名字相同。当程序中创建多个类时，必须运行包含main()方法的类，

否则，出错。

6.2.2 类成员

1.类成员变量

(1) 在类中声明成员变量时，没有使用static修饰的变量为实例成员变量，使用static修饰的变量为类成员变量

class Student
{
  String name;           //实例成员变量
  String sex;            //实例成员变量
  static int count=0;   //类成员变量
 public Student(String m, String s )
{  name=m;
   sex=s;
   count=count+1;    }     }

(2).当创建对象时，每个对象拥有各自的实例成员变量，各对象的实例成员变量具有不同的值；

而系统仅为类成员变量分配一个存储单元，所有对象共享一个类成员变量。

(3) 实例成员变量属于对象，只能通过对象引用；类成员变量属于类，既可以通过类名访问

，也可以通过对象名访问。实例成员变量的访问方法为：

对象名. 实例成员变量名

类成员变量的访问方法为：

对象名.实例成员变量名或类名.实例成员变量名

例:6-8

类成员变量和实例成员变量的对比
class Student1
 {
  String name;              //实例成员变量
  String address;           //实例成员变量
  static int count=0;      //类成员变量
  public Student1(String m, String a )
  { name=m;
    address=a;
    count=count+1;
  }
  public static void main(String args[])
 {
Student1 p1=new Student1("李明","西安市未央区");
   Student1 p2=new Student1("张敏", "上海市闽行区");
   System.out.println(p1.name+" "+p1.address+" "+p1.count);
   Student1.count=Student1.count+1;
   System.out.println(p2.name+" "+p2.address+" "+p2.count);
   p1.count=p1.count-1;
   System.out.println(p2.name+" "+p2.address+" "+p2.count);
  }
}

程序运行结果如下：

李明西安市未央区 2

张敏上海市闽行区 3

张敏上海市闽行区 2

2.类成员方法

在类中声明成员方法时，没有使用static修饰的方法为实例成员方法，使用static修饰的方法为类成员方法。

public static double area(double r)

{

return 3.14*r*r;

}

类成员方法中除使用本方法中声明的局部变量外，只可以访问类成员变量，不能访问实例成

员变量；实例成员方法中除使用本方法中声明的局部变量外，还可以访问类成员变量及实例成员变量

例6-9

例：类成员方法和实例成员方法的对比
class Course
{ String no;                           //实例成员变量：课程编号
   int score;                           //实例成员变量：成绩
   static int sum=0;                     //类成员变量：总成绩
   public  Course(String n, int s)
   { no=n;
      score=s; }
 public static void summarize(int s)      //类方法：统计总成绩
 {  sum+=s; }
}
public class Statistic
{ 
    public static void main(String args[])
  { Course c1,c2;
    c1=new Course("210",90);
    Course.summarize(90);
    System.out.println("sum="+c1.sum);
    c2=new Course("300",80);
    c2.summarize(80);
    System.out.println("sum="+Course.sum);
  }
}

程序运行结果如下：

sum=90

sum=170

3 数学函数类—— Math类库

Java类库中的Math类提供了很多常用数学函数的实现方法，这些方法

都是static方法，通过类名Math调用，其调用方式如下：

Math.方法名

Math类中的常用方法包括：

sin(double x)

cos(double x)

log(double x) //返回x的自然对数

exp(double x) //返回ex

abs(double x) //返回x的绝对值

max(double x, double y) //返回x和y中的较大值

sqrt(double x) //返回x的平方根

random(double x) //返回[0, 1]区间内的随机数

pow(double y, double x) //返回yx

例6-10 输入两个数.输出其中较大者

  public class Max
  {
    public static void main(String args[])
    {
      int x,y;
      x=Integer.parseInt(args[0]);
      y= Integer.parseInt(args[1]);
      System.out.println("最大值是"+Math.max(x,y));
     }
   }

posted @ 2013-04-03 12:43 elite_2012 阅读(405) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

java 语言程序设计-李尊朝 第6章 类和对象

java 语言程序设计-李尊朝第6章类和对象