nullJava 程序设计
教程
人力资源管理pdf成真迷上我教程下载西门子数控教程protel99se入门教程fi6130z安装使用教程
Java 程序设计教程null第一节 面向对象程序设计概述
第二节 类的创建
第三节 对象的创建
第四节 类的封装
第五节 类的继承
第六节 类的多态性
第七节 接口
第八节 包null一. 什么是对象
对象具有的特性:
(1)万物皆为对象
(2)每个对象都是唯一的(每个对象分配的内存地址不同)
(3)对象具有属性和行为
(4)对象具有状态:某个瞬间对象的各个属性的取值。
张三 01号 21岁 上课 吃饭 睡觉 属性: 姓名 学号 年龄
行为: 上课 吃饭 睡觉null二、什么是类
什么是类?
类是一组具有相同属性和行为的对象的集合。
null三、类和对象的关系
1 . 区别类是一个抽象的概念,对象是具体的事物
null2.联系
对象都属于某一个类
同一个类的所有对象具有相同属性,属性值
不一定相同,但行为都相同。姓名 学号 年龄 上课 吃饭 睡觉
张三 01 21
李四 02 20null四、类的创建
1 类的声明格式
class 类名称{
类主体
}
null
2 类的语法格式
class 类名{
变量类型 变量名
返回类型 方法名 (参数) {方法体}
}
null
3 学生类的创建
class Student{
String name;
int number;
int age;
float weight;
void study(){……}
void eat(){……}
void sleep(){……}
}null五、对象的创建
1.语法格式:
类名 对象名 = new 类名();
null
2.学生对象的创建
Student 张三 = new Student();
Student 李四 = new Student();null六、面向对象程序设计的核心技术
面向对象程序设计的核心技术是封装、继承和多态性。
null封装是把对象的属性和行为组合成为一个独立的单位或部件,并尽可能隐蔽对象的内部细节,而只保留必要的对外接口,使之与外部发生联系。 1. 封装:对象A对象B私有数据
方法
方法
数据公有数据null自行车(超 类)山地车双人车子 类公路自行车2. 继承:nullclass Car
{ int color_number;
int door_number;
int speed;
brake() { … };
speedUp() {…};
} class Trash_Car
extends Car
{
fill_trash() { … }
}null多态性:同一个消息可以根据发送消息对象的不同产生多种不同的行为方式。 null 本节导航
4.2.1 类的声明格式
4.2.2 成员变量
4.2.3 成员方法
4.2.4 成员变量与局部变量区别
null4.2.1 类的声明格式
Class 类名称{
类主体
}
类首声明定义了类的名字、访问权限与其它类的关系等。
类主体定义了类的成员,包括变量(数据)和
函数
excel方差函数excelsd函数已知函数 2 f x m x mx m 2 1 4 2拉格朗日函数pdf函数公式下载
(方法)
null 1.类首声明:
[<修饰符>] class <类名> [extends <超类名>] [implements <接口名>]
class: 类定义的关键字;
extends:
表
关于同志近三年现实表现材料材料类招标技术评分表图表与交易pdf视力表打印pdf用图表说话 pdf
示类和另外一些类(超类)的继承关系;
implements: 表示类实现了某些接口;
修饰符: 表示类访问权限(public、private等)和一些其它特性(abstract、final等);
null
例如:
public class Date1
声明Date1类,访问权限为Public,表示类Date1可以被该类所属的包之外的类使用。
null 2.类主体
<类首声明>
{
<成员变量的声明>
<成员方法的声明及实现>
}
成员变量即类的数据,反映了类的属性和状态。
成员方法即类的行为(对数据的操作)
null 4.2.2 成员变量
[<修饰符>] [static] [final] [transient] <变量类型> <变量名>
static: 表示是一个类变量(静态变量);
final: 表示是一个常量;
transient: 表示一个临时变量
修饰符: 表示变量的访问权限(缺省访问、public、protected和private)
null4.2.3 成员方法
[<修饰符>] <返回类型> <方法名> ([<参数表列>])[throws <异常类>]
{ 方法体 }
修饰符:方法的访问权限(缺省的、public、protected和private)
static: 类方法(静态方法);
abstract: 抽象方法(无方法体的方法);
final: 最终方法(不能被子类改变)。
throws: 表示抛出异常null
声明一个学生类Student,
成员变量包括:
id(学号)
name(姓名)
height(身高)
weight(体重)
age(年龄)
score(成绩)
成员方法包括:
sing(唱歌)
study(学习)
null举例:
定义一个梯形类,其中定义4个double类型变量“上底”、“下底”、“高”、“梯形面积”;定义了一个方法“梯形面积”,求梯形的面积。
null举例:
定义一个日期类,其中定义3个变量“年”、“月”、“日”;定义了一个方法“打印日期”,该方法负责打印当前的日期,日期格式为:2010/3/2
null
例4.2.1:声明一个日期类Date1
public class Date1
{ int year,month,day; //成员变量
public void today( ) //成员方法
{System.out.println(“Date is”+year+”/”+month+”/”+day);}
}
4.2.4 成员变量和局部变量区别
4.2.4 成员变量和局部变量区别
成员变量:变量定义部分所定义的变量。
局部变量:在方法体中定义的变量和方法的参数。
区别:
1.成员变量在整个类内都有效,局部变量只在定义它的方法内有效。成员变量与他书写的位置无关
null2.如果局部变量的名字与成员变量的名字相同,则成员变量被隐藏,即这个成员变量在这个方法内暂时失效 .这时如果想在该方法内使用成员变量,必须使用关键字this。
null 本节导航
4.3.1 创建对象
4.3.2 构造方法和对象初始化
4.3.3 对象的使用
4.3.4 对象的引用和实体
4.3.5 对象的销毁
4.3.6 参数的传递
null4.3.1 创建对象第一种形式:
(1)声明对象
<类名> <对象名>
作用:声明一个引用变量,仅仅是预定变量的存储空间,并没有对象实体生成,此时的对象被称作空对象。
(2) 实例化对象(new)
<对象名> = new <类名>()
作用:在内存中为此对象分配内存空间,并返回对象的引用(即对象的存储地址)。
null<对象名> = new <类名>()
系统做的两件事:
1.为各个成员变量分配内存,然后执行构造方法中的语句。如果成员变量在声明时没有指定初值,所使用的构造方法也没有为成员变量进行初始化操作,那么,根据变量的类型给出默认值。
2.给出一个信息,确保这些变量是属于该对象的。返回一个号码,这个号码包含着代表这些成员变量内存位置的首地址等重要的有关信息给该对象。null 第二种形式:声明对象的同时,将它实例化
<类名> <对象名> = new <类名>()
实例化就是为对象分配存储空间,并同时对对象进行初始化。这些工作分别用new运算符和类的构造方法来完成。
null创建多个不同的对象
一个类通过new运算符可以创建多个不同的对象,这些对象将被分配不同的内存空间。因此,改变一个对象的状态不会影响其他对象的状态。
Student s1 = new Student();
Student s2 = new Student ();
null
引用成员变量或成员方法时要用 ”.” 运算符
成员变量的引用格式:
<对象名>.<变量名>
成员方法的调用格式:
<对象名>.<方法名([参数])>
4.3.3 对象的使用nullnull 构造方法是一种特殊的方法,类的构造方法可以使我们在创建对象时进行初始化(对成员变量赋初值)。
当用new创建一个类的新的对象时,构造方法就立即执行。
如果不想进行初始化,就调用类的默认构造方法。
4.3.2 构造方法和对象的初始化1.默认的构造方法1.默认的构造方法 类名(){ }
Student(){}
2.如何创建构造方法2.如何创建构造方法 构造方法名字必须与类名相同。
构造方法没有返回值(在构造方法名字前
连void也不要加)
注意:除了构造方法,在类中不能出现与类名相同的方法。
null
例4-1:声明一个日期类Date1
public class Date1
{ int year,month,day; //成员变量
public void today( ) //成员方法
{ System.out.println(“Date
is”+year+”/”+month+”/”+day);
}
}在此例中,成员变量year、month、day分别表示日期的年、月、日,成员方法today表示对属性的操作,即打印今天的日期。null
三个参数分别用来对成员变量year、month、day进行初始化。null Date1 de = new Date1();
调用了类的缺省构造方法,无参数。
Date1 de = new Date1(1999,12,31);
调用了自己创建的构造方法,对类的成员变量 year、month、day分别赋初值1999、12、31。
null说明: Java语言中每个类都有构造方法,如果一个类中没有创建构造方法,创建对象时不进行初始化,则系统自动调用默认的构造方法,这个构造方法其实什么也不做;但是如果类中创建了自己的构造方法,在创建对象时又不想进行初始化,系统不会给出默认的构造方法了,所以这个默认的构造方法就需要我们自己在类中创建。否则,应用创建对象的语句时会出错。
null2.无参数的构造函数
如果有自己创建的构造函数,而创建某些对象时又不想进行初始化,一定要在类中创建无参数的构造函数,因为此时已没有缺省的构造函数了。
设计一个长方形类,成员变量包括长和宽。类中有计算面积和周长的方法;有构造函数,为长方形的长和宽赋值。
定义一个测试类,并输出长方形的周长和面积。
设计一个长方形类,成员变量包括长和宽。类中有计算面积和周长的方法;有构造函数,为长方形的长和宽赋值。
定义一个测试类,并输出长方形的周长和面积。
设计一个圆类,成员变量包括半径r。类中有计算面积的方法;有构造函数,为圆的半径赋值。
定义一个测试类,并输出圆的面积。
设计一个圆类,成员变量包括半径r。类中有计算面积的方法;有构造函数,为圆的半径赋值。
定义一个测试类,并输出圆的面积。
编写一个类,该类封装了一元二次方程共有的属性和功能,即该类有刻画方程系数的3个成员变量以及计算实根的方法。提示:
(1) 求根公式为:
(-b+sqr(b2-4ac))/2a
(-b-sqr(b2-4ac))/2a
(2) 求平方根方法是sqrt(),是java.lang包中的Math类的类方法。该方法的描述如下:
public static double sqrt(float a )
编写一个类,该类封装了一元二次方程共有的属性和功能,即该类有刻画方程系数的3个成员变量以及计算实根的方法。提示:
(1) 求根公式为:
(-b+sqr(b2-4ac))/2a
(-b-sqr(b2-4ac))/2a
(2) 求平方根方法是sqrt(),是java.lang包中的Math类的类方法。该方法的描述如下:
public static double sqrt(float a ) null
null当用一个类创建一个对象时,类中的成员变量被分配内存空间,这些内存空间被称作该对象的实体,而对象中存放着引用,以确保实体由该对象操作使用。
Point p1 = new Point(12,16)
Point p1 = new Point(6,18)
p1=p2
内存如何表示?4.3.4 对象的引用和实体null
一个类创建的两个对象,如果具有相同的引用,那么就具有完全相同的实体。
没有实体的对象称作空对象,空对象不能使用,即不能让一个空对象去调用方法产生行为。 否则会出现NullPointerException异常。
null
实际上,java有所谓的“垃圾回收”机制,这种机制周期的检测某个实体是否已不再被任何对象所拥有,如果发现这样的实体,就释放实体占有的内存。
null1.两个概念
对象的生命周期是指对象的创建、使用和销毁这一过程。
对象的销毁是指当对象使用完毕后,释放对象所占有的资源(如分配给它的内存)。
4.3.5 对象的销毁null2.对象销毁的方法
<修饰符> void finalize(){方法体}
finalize方法没有参数,没有返回值,且一个类只能定义一个finalize方法。
注意:该方法的运行发生在对象销毁之前。
1.变量或者常量作为参数的传递
2.应用程序被调用时有参数的情形
3.引用类型参数的传递
1.变量或者常量作为参数的传递
2.应用程序被调用时有参数的情形
3.引用类型参数的传递
4.3.6 参数的传递null例3-20 参数传递示例。
程序如下:
class Cylinder {
double v_Cyli;
public void Cylical(int r,int h) {
v_Cyli=3.14*r*r*h;
}
public void display() {
System.out.println("V="+v_Cyli);
}
}
public class CCyliClass {
public static void main(String args[]) {
Cylinder yz1 = new Cylinder();
yz1.Cylical(7,8);
yz1.display();
}
}
null当数组作为参数传递时,只需在实参的位置上输入数组名即可。
在java应用程序中,程序的执行是从主方法开始的。
public static void main(String args[ ])
arg[]是一个字符串数组,用来接收应用程序被调用时由用户直接从键盘输入的参数,其中arg[0]表示所接收的第一个参数,以此类推。
在java应用程序中,程序的执行是从主方法开始的。
public static void main(String args[ ])
arg[]是一个字符串数组,用来接收应用程序被调用时由用户直接从键盘输入的参数,其中arg[0]表示所接收的第一个参数,以此类推。
null引用类型(包括类、接口、数组)参数的传递,传递的是变量的引用,而不是变量引用的实体。
如果改变参数变量所引用的实体,就会导致原变量的实体发生同样的变化。
引用类型(包括类、接口、数组)参数的传递,传递的是变量的引用,而不是变量引用的实体。
如果改变参数变量所引用的实体,就会导致原变量的实体发生同样的变化。
nullnullpublic class Test1 {
public static void main(String[] args) {
int n = 3;
System.out.println("Before change, n = " + n);
changeData(n);
System.out.println("After changeData(n), n = " + n);
}
public static void changeData(int n) {
n = 10;
}
}nullpublic class Test2 {
public static void main(String[] args) {
StringBuffer str = new StringBuffer("Hello ");
System.out.println("Before : " + str);
changeData(str);
System.out.println("After : " + str);
}
public static void changeData(StringBuffer strBuf) {
strBuf.append("World!");
}
}nullpublic class Test3 {
public static void main(String[] args) {
StringBuffer str = new StringBuffer("Hello ");
System.out.println("Before : " + str);
changeData(str);
System.out.println("After : " + str);
}
public static void changeData(StringBuffer strBuf) {
strBuf = new StringBuffer("Hi ");
strBuf.append("World!");
}
}nullclass TransParam{
public static void main(String[] args){
StringBuffer s= new StringBuffer("cat");
StringBuffer s2=new StringBuffer("dog");
test(s,s2);
System.out.println(s);
System.out.println(s2);
}
static void test(StringBuffer a,StringBuffer b){
System.out.println(a);
System.out.println(b);
b=a;
a=new StringBuffer("pretty");
System.out.println(a);
System.out.println(b);
a.append("animal");
b.append("animal");
}
}null 本节导航
4.4.1 封装的目的
4.4.2 访问权限的设置
4.4.3 static修饰符
null4.4.1 封装的目的 类的封装的目的,就是限制在类的外部对类内部成员进行访问。并通过公共接口来访问类的成员数据。
封装的另一目的是细节屏蔽,这是程序设计的基本思想方法。便于程序功能的扩展和程序的维护。4.4 类的封装null4.4.2 访问权限的设置
null类的访问权限的设置
类的权限有两种:默认和public。如果在一个源程序文件中,声明了若干个类的话,只能有一个类的权限关键字是public。这个类的名字应该和程序文件同名,main方法也应该在这个类中。
类的成员的访问权限设置
用权限关键字设置类的成员的权限,可以决定是否允许其类外部的代码访问这些成员。
null
4.4.3 static 修饰符 在类中声明一个变量或方法时,还可以指定它为实例成员或类成员。
由static修饰的成员叫做类成员,否则叫做实例成员。null
实例变量
类变量
3. 实例方法
4. 类方法(1) 实例变量(1) 实例变量
在生成每个类的实例变量时,java运行系统为每个对象的实例变量分配一个内存空间,然后通过对象来访问这些实例变量。
不同对象的同名实例变量占用不同的内存空间。
通过对象名来访问实例变量(2) 类变量(2) 类变量
类变量可以被所有的对象共享。在一个对象也没有被创建时,类变量就存在了。当程序运行结束,类变量才被撤消。
同一类中的所有对象的类变量共享一个存储空间。一个对象对类变量的操作,会影响到同一类的其它对象。
可以使用类名引用类变量,也可以使用对象名引用类变量。null
null
(3) 实例方法(3) 实例方法
实例方法可以对当前对象的实例变量和类变量进行操作。
实例方法必须由实例对象调用。
(4) 类方法(4) 类方法
类方法只能对类变量进行操作。
类方法可以用类名调用,也可以用对象名调用。类方法不用将类实例化就可以直接调用。如果类方法与调用它的程序处于同一个类中,则调用时类名也可以省略。null
null
null
null
null
举 例举 例
将Melon类的类变量total_weight和total_number的访问权限声明为private。要创建两个类方法get_ total_weight和get_ total_number来访问两个类变量。
Melon1_ex.java4.5 类的继承4.5 类的继承如果要扩展一个程序的功能,可以对原来的类进行修改或增加一个新的类。这样要么会影响到那些和原来的类有关系的类,要么会造成代码的重复,一种好的方法是通过继承来重用已有的代码,同时增加新的代码来进行功能的扩展。
4.5.1 继承的基本概念4.5.1 继承的基本概念
超类(父类):被继承的类叫做超类
子类:从超类派生出来(继承超类)的新类叫
做子类null自行车(超 类)山地车双人车子 类公路自行车null
所有的java类都直接或间接的继承了java.lang.Object类。Object类是所有类的祖先。说明说明
如果类Sub是类Super的子类,则类Sub继承了
超类Super的变量和方法。
子类Sub中,包括两部分的内容:从超类
Super中继承下来的变量和方法,自己新增加
的变量和方法。
在Java中,只支持单重继承,不支持多重继
承,所以一个类只能有一个超类。4.5.2 子类的创建4.5.2 子类的创建
1.声明子类
2.子类如何继承超类的成员变量
3.子类如何继承超类的成员方法
1. 声明子类1. 声明子类
在声明子类的同时,声明类的超类
[<修饰符>] class <子类名> extends <超类名>
{ 子类成员变量声明
子类成员方法声明 }
如:class Trash_Car extends Car
{ 子类体 }
子类的每个对象也是超类的对象。超类的对象不一定是子类的对象。
2. 子类继承超类的成员变量2. 子类继承超类的成员变量
继承原则:子类只继承超类中非private的成
员变量
隐藏原则:子类的成员变量和超类的成员变
(Hiding)量同名时,超类的成员变量被隐
藏。若想使用超类的成员变量用
super。
null
例:声明一个Person类,再声明一个Student类,作为Person类的子类。
Student_ex.javanull
例:声明一个Person类,再声明一个Student类,作为Person类的子类。
Student_ex.javanull
3. 子类继承超类的成员方法3. 子类继承超类的成员方法
继承原则:子类只继承超类中非private的成
员方法
覆盖原则:子类的成员方法和超类的成员方
(Override)法同名时,超类的成员方法被隐
藏。
null
例:对上例中声明的两个类进行了修改,使用了方法的隐藏继承原则
Student1_ex.java
null
null
null4. 子类的构造函数子类不能继承父类的构造方法。
在调用子类的构造方法时,要先调用父类的构造方法。
如果子类想使用父类的构造方法,必须在子类的构造方法中使用super关键字来调用,且必须是子类构造方法中的第一条语句。
如果在子类的构造方法中没有使用super调用父类的某个构造方法,则系统在执行子类的构造方法时会自动调用父类的默认的构造方法(即无参的构造方法)。
4.5.3 几种对象运算符4.5.3 几种对象运算符
1. null
2. this
3. super1. null1. null
null 表示类的空对象,即没有创建类的任何实例 2. this2. this
使用this表示正在使用该方法的对象
this引用的使用方法如下:
1. 访问本类的成员:
this.<变量名>
this.<方法名>
2. 调用本类的构造函数
this([参数列表])
3. super3. super
Super有三种情况可以使用:
(1) 用来访问父类中被隐藏的成员变量。
(2) 用来访问父类中被覆盖的方法;
(3) 用来调用父类中的构造方法;null
如果子类和超类有同名的成员变量或方法,则:
super.<成员变量名>
super.<成员方法名>
表示引用超类的成员(如无super则表示引用子类中的同名成员)
用super调用超类的构造方法
super([参数列表])null
null4.5.4 最终类和抽象类4.5.4 最终类和抽象类
最终类和最终方法
2. 抽象类和抽象方法1. 最终类和最终方法1. 最终类和最终方法
用final修饰的类为最终类。最终类不能有子类。
用final修饰的方法为最终方法。最终方法不会在子类中被覆盖(即子类中不能有和此方法同名的方法)。2. 抽象类和抽象方法2. 抽象类和抽象方法
抽象方法用关键字abstract修饰。只允许声明,不设方法体。抽象方法是必须被子类覆盖的方法。如:
abstract void write() ;
用abstract修饰的类叫做抽象类,抽象类不能用new运算符创建对象。抽象类中可以有抽象方法也可以没有。
一旦类中包括了抽象方法就必须声明为abstract
若超类是抽象类,子类必须实现超类中所有抽象方法抽象方法,不能用static、final修饰。
抽象类,不能用final修饰。null
5.下列说法正确的 ( )
A.用abstract修饰的方法,不能再被子类重写
B.用final修饰的方法,不能再被子类重写
C.抽象类中一定要包括abstract方法
D.某个类中包含了abstract方法,该类可以不声明为abstract类null
44. 假设类 A 有构造方法 A(int a) ,则在类 A 的其他构造方法中调用该构造方法的语句格式应为 ( )
A. A(x) B. this. A(x) C. this(x) D. super(x) null
51. 下面是有关子类继承父类构造函数的描述,其中正确的是( ) A.如果子类没有定义构造函数,则子类无构造函数
B. 子类构造函数必须通过super关键字调用父类的构造函数
C.子类必须通过this关键字调用父类的构造函数
D. 子类无法调用父类的构造函数null
4.6 类的多态4.6 类的多态
什么是多态性:多态性是指同一个名字的若干个方法,有不同的实现(即方法体中的代码不一样)。
当我们用一个方法名调用方法时,执行的是这些方法的不同版本中的一种。
多态性通过方法重载和方法覆盖来实现4.6.1 方法的重载4.6.1 方法的重载
什么是重载(overloading):在一个类中,定义多个名称相同,但参数个数或参数类型不同的方法,java根据参数的个数或参数类型,调用相对应的方法。
重载的关键是参数的类型或个数必须不同。
null
public void funover(int a)
public void funover(int a,float b)
public void funover(float a,int b)
public void funover(int a,float b)
public int funover(int a,float b)
null
4.6.2 方法的覆盖4.6.2 方法的覆盖
什么是覆盖(overriding):是指在子类中,定义名称、参数个数与类型均与父类相同的方法,以重写父类中的方法的功能。
null
4.6.3 前期绑定和后期绑定对于方法的重载,在程序编译时,根据调用语句中给出的参数,就可以决定在程序执行时调用同名方法的版本。这称为编译时的绑定(前期绑定)。
对于方法的覆盖,要在程序执行时,才能决定调用同名方法的版本。这称为运行时的绑定(后期绑定)。
当子类对象赋给超类对象或作为参数传递给超类对象时,超类对象调用子类中的同名方法。 4.6.3 前期绑定和后期绑定4.7 接口 在Java中,一个类只能有一个超类。但Java提供了接口用于实现多重继承,一个类可以有一个超类和多个接口。4.7 接口4.7.1 接口的声明接口由常量和抽象方法组成。
[修饰符] interface <接口名>
{接口体}
修饰符:可以是public或默认访问控制。
接口体中的变量隐含为public final和static,它们必须被赋初值。
接口体中的方法隐含为public、abstract。都是抽象方法。必须在类中实现。4.7.1 接口的声明4.7.2 接口的实现一个类通过使用关键字implements实现一个或者多个接口。
class <类名> implements <接口名1>,<接口名2> 。。
当一个类实现了一个接口,它必须实现接口中所有的方法,这些方法都要被声明为public。
注意:方法的名字、返回类型、参数个数及类型必须与接口中方法一致。
4.7.2 接口的实现null4.8 包4.8.1 Java的类和包
java常用的包有:
java.lang 语言包
java.util 实用包
java.awt 抽象窗口工具包
java.text 文本包
java.io 输入输出流的文件包
java.applet Applet应用程序
java.net 网络功能
4.8 包null语言包:java.lang提供了Java最基础的类,只有java.lang包不需要导入就能使用
Object
数据类型类
String和StringBuffer
Math
System,Runtime
Class
ClassLoader
错误和异常处理类
null实用包
java.util包提供了实现各种实用功能的类,如日期类、集合类等。
日期类包括Date、Calendar和GregorianCalendar类
集合类包括多种集合接口:Collection(无序集合)、Set(不重复集合)、List(有序不重复集合)和Enumeration(枚举)。
数据结构有关的类:Linklist(链表)、Vector(向量)、Stack(栈)、Hashtable(散列表)和Treeset(数)。 null4.8.2 引用Java定义的包
1.导入包
import java.applet.Applet; //导入Java.applet包中的Applet类
import java.awt.* //导入Java.awt包中所有的类
2.Java包的路径:设置classpath路径
classpath =.; d:\j2sdk1.4.2_02\lib
null4.8.3自定义包
如果在程序中没有声明包,类就放在默认的包中,这个包是没有名字的。
1.声明包的格式
package <包名>;
声明一个包的语句要写在源程序文件的第一行。
2.设置包的路径
创建一个和包同名的文件夹(字母大小写也一样),将包含包的源程序文件(.java)和编译产生的.class文件放到此文件夹中,设置环境变量classpath
3.引用包中的类
如果引用其它包中的类,可用import语句
null4.包路径的层次结构
包对应于一个文件夹,而类则是文件夹中的一个文件。包路径也可以有层次结构,如:
package Firstpackage.package1
用“.”将包的名字分开,形成包路径的层次,package1是Firstpackage文件夹的子文件夹。
5. Java源程序文件的结构
一个Java的源程序文件依次有以下部分:
包的声明语句
包的导入语句
类的声明
null4.8.4包和访问权限
一个包中只有访问权限为public的类才能被其它包引用(创建此类的对象),其它有默认访问权限的类只能在同一包中使用。
在不同包中类成员的访问权限。
public类的成员
public类的public成员可以被其它包的代码访问。它的protected成员可以被由它派生的其它包中的子类访问。
默认访问权限类的成员
默认访问权限类的成员,不能被其它包的代码访问