Java基础中的“类”知识
Java类的内容
一、类的定义和声明
Java编程语言是面向对象的，处理的最小的完整单元为对象。而现实生活中具有共同特性的对象的抽象就称之为类。类由类声明和类体构成，类体又由变量和方法构成。
下面给出一个例子来看一下类的构成。
例1
自定义一个apple类，在主类SetApple中创建实例并调用方法，输出结果如图1所示。源程序代码如下：
//程序文件名为SetApple.java
public class SetApple
{
public static void main(String[] args)
{
apple a=new apple();//创建apple类
a.appleweigt=0.5;//实例变量赋值
System.out.println("苹果的重量为1两");
System.out.println(a.bit());//调用实例方法
a.appleweight=5;
System.out.println("苹果的重量为5两");
System.out.println(a.bit());
}
}
//自定义类
class apple
{
//属性
long applecolor;//对应苹果的颜色
double appleweight;//苹果的重量
boolean eatup;//是否吃完
//类方法
public boolean bite()
{
if(appleweight<1)
{
System.out.println("苹果已经吃完了！哈哈");
eatup=true;
}
else
{
System.out.println("苹果吃不下了！：(");
eatup=false;
}
return eatup;
}
}
1、类声明的基本格式
访问说明符class类名extends超类名implements接口名
其中：
（1）访问说明符为public或者缺省。public用来声明该类为有类，可以被别的对象访问。声明为公有的类存储的文件名为类名。
（2）类名：用户自定义的标识符，用来标志这个类的引用。
（3）超类名：是指已经存在的类，可以是用户已经定义的，也可以是系统类。
（4）接口名：即后面讲到的接口。
例如：
public class HelloApplet extends Applet
访问说明符为public,类名HelloApplet，扩展类为JDK包自带的java.applet.Applet类。由于public的存在，所以文件名必须存为HelloApplet.java，同类名保持一致。
2、类体
类体包括成员变量和方法。
（1）成员变量：
指类的一些属性定义，标志类的静态特征，它的基本格式如下：
访问说明符 数据类型 变量名
其中：
访问说明符有public、private和protected三种：
public:省略时默认为公有类型，可以由外部对象进行访问。
private:私有类型，只允许在类内部的方法中使用，若从外部访问，必须通过构造函数间接进行。
protected:受保护类型，子类访问受到限制。
数据类型包括基本类型以及用户自定义的扩展类型。
（2）方法：
昌类的操作定义，标志类的动态特征，它的基本格式如下：
访问说明符 数据类型 方法名(数据类型1 变量名1，数据类型2 变量名2)
其中：
访问说明符为public、private和protected，其使用方法与成员变量访问说明符的使用方法一致。
数据类型：包括基本数据类型和用户自定义的扩展类型。
数据类型为参数。
3、创建类的实例
使用关键字new进行创建，例如：
HelloApplet hp=new HelloApplet();
例1中，自定义类apple，访问标识符缺省，定义三个属性：
long applecolor;//对应苹果的颜色
double appleweight;//苹果的重量
boolean eatup;//是否吃完
一个方法为：
public boolean bite()//类方法{...}
公有类SetApplet中引用自定义类，首先创建类的实例：
apple a=new apple();
其次赋初值：
a.appleweight=0.5;//实例变量赋值
最后调用它的方法：
System.out.println(a.bite());//调用实例方法
二、类的单继承性
Java编程语言中允许用extends关键字从一个类扩展出一个新类，新类继承超类的成员变量和方法，并可以覆盖方法。
例2：测试类的单继承性，程序输出结果如图2所示。源程序代码如下：
//程序文件名TestExtend.java
public class TestExtend exends Employee
{
public static void main(String[] args)
{
System.out.println("覆盖的方法调用:"+getSalary(王一",500));
System.out.println("继承的方法调用:"+getSalary2("王一",500));
System.out.println("覆盖的方法调用:"+getSalary("王飞",10000));
System.out.println("继承的方法调用:"+getSalary2("王飞",10000));
}
public static String getSalary(String name,int salary)
{
String str;
if(salary>5000)
str="名字:"+name+" Salary:"+salary;
else
str="名字:"+name+" Salary:低于5000";
return str;
}
};
class Employee
{
public String name;//名字
public int salary;//薪水
public static String getSalary(String name,int salary)
{
String str;
str="名字:"+name+" Salary:"+salary;
return str;
}
public static String getSalary2(String name,int salary)
{
String str;
str="名字:"+name+" Salary:"+salary;
return str;
}
};
程序中定义了父类Employee类，它有两个方法getSalary和getSalary2，方法体的实现都是一致的，都为输出名字和薪水的值。在TextExtend主类中覆盖了getSalsry方法，方法体重新定义为薪水低于5000时并不输出薪水的值而是输出“低于5000”，用于和继承的getSalary2方法进行比较。由图2可以看出覆盖调用父类中的方法。
三、特殊变量
类中有两个特殊变量super和this。
1、super
类声明中用关键字extends扩展了其超类之后，super用在扩展类中引用其超类中的成员变量。
例3：使用super变量，输出结果。源程序代码如下：
//程序文件名为UseSuper.java
public class UseSuper
{
public static void main(String[] args)
{
Manager m=new Manager();
m.name="王飞";
m.salary=10000;
m.department="业务部";
System.out.println(m.getSalary());
}
}
class Employee
{
public String name;//名字
public int salary;//薪水
//方法
public String getSalary()
{
String str;
str="名字:"+name+"\nSalary:"+salary;
return str;
}
}
class Manager extends Employee
{
public String department;//部门
//方法
public String getSalary()
{
//使用super变量调用超类的方法
return super.getSalary()+"\nDepartment:"+department;
}
}
2、this
this变量指向当前对象或实例。
str="名字:"+name+"\nSalary:"+salary;
上例中的语句可以换成下面的语句。
str="名字:"+this.name+"\nSalary:"+this.salary;
这两者是等同的，因为在Java编程语言中，系统自动将this关键字与当前对象的变量相关联。但有一种情况例外，就是当在某些完全分离的类中调用一个方法并将当前对象的一个引用作为参数传递时。
例如：
Day d=new Day(this);
四、构造函数
类中的构造函数用来初始化一个类。构造函数为公有类型，无返回值，用来从类实例中访问类时初始化此类的私有变量。
例4：基于例3将公有变量改成私有变量之后，增加两个构造函数，访问通过外部调用构造函数实惠初始化赋值。
//程序文件名为UseConstruct.java
public class UseConstruct
{
public static void main(String[] args)
{
Manager m=new Manager("王飞",10000,"业务部");//初始化赋值
System.out.println(m.getSalary());
}
}
class Employee
{
private String name;//名字
private int salary;//薪水
//构造函数
public Employee(String_name,int_salary)
{
name=_name;
salary=_salary;
}
public String getSalary()
{
String str;
str="名字:"+name"\nSalary:"+salary;
return str;
}
}
class Manager extends Employee
{
private String department;
//构造函数
public Manager(String_name,int_salary,String_department)
{
super(_name,_salary);
department=_department;
}
public String getSalary()
{
return super.getSalary()+"\nDepartment:"=department;
}
五、包
计算机操作系统使用文件夹或者目录来存放相关或者同类的文档，在Java编程语言中，提供了一个包的概念来组织相关的类。包在物理上就是一个文件夹，逻辑上代表一个分类概念。
包就是指一组类。例如一个名叫Company的包，可以包含一组类，如Employee（雇员）、Manager（管理者）和Department（部门）等。声明包的基本格式如下：
Package包名;
其中：Package为关键字，包名为标识符。
使用包时的注意事项如下：
1、Package语句要作为程序非注释语句的第一行语句。
2、包内的类名惟一。
3、引用包中的类时，使用import语句。import语句的基本格式为import包名.类名，其中import为关键字，包名和类名之间用圆点(.)隔开。
例5：编写程序开发测试包，先建立一个Company文件夹，然后建立名为Manager.java的类文件。源程序代码如下：
//程序文件名为Manager.java
package Company;//声明包名Company
class Employee
{
public String name;//名字
public int salary;//薪水
public String getSalary()
{
String str;
str="名字:"+name+"\nSalary:"+salary;
return str;
}
}
public class Manager extends Employee
{
public String department;//部门
public String getSalary()
{
return super.getSalary()+"\nDepartment:"+department;
}
}
对此文件进行编译，生成文件Manager.class。
在原目录建立源程序文件UsePackage.java。源程序开发代码如下：
//程序文件名UsePackage.java
import Company.Manager;//引入包中的类
public class UsePackage
{
public static void main(String[] args)
{
Manager m=new Manager();
m.name="王飞”；
m.salary+10000;
m.department="业务部";
System.out.println(m.getSalary());
}
}
编译后，在命令提示符状态下运行。从中可以看出首先进入Company目录，编译Manager.java文件，然后返回上层目录，编译UsePackage.java文件，然后返回上层目录，编译UsePackage.java文件，最后执行UsePackage类文件，输出正确的结果。
浙公网安备 33010602011771号