《Java程序设计》电子课件第1篇 核心基础篇第 3 章 Java面向对象特性宋波，李晋，李妙妍，张悦本章内容3.1 类与对象
3.2 隐藏和封装3.3 类的继承与多态3.4 数组学习目标掌握对象与类的基本概念了解对象的生命周期熟练掌握类的定义及实例
化理解隐藏与封装熟练掌握类的继承与多态掌握数组的应用本章概要Java中类和对象的定义；Java对OOP三个主要特性——封装、继承
和多态的支持机制；Java中的对象数组这种数据结构。3.1 类与对象类与对象的定义成员变量与局部变量成员方法对象的创建对象的使
用对象的消除方法重载this构造方法3.1.1 类和对象的定义Java程序是由一个或若干个类组成，类是Java程序的基本组成单
位，包括：成员变量：描述对象的属性成员方法：描述对象的行为类定义的结构宋波，李晋，李妙妍，张悦1. 类的声明格式 [publ
ic] [abstract | final] class [extends superCla
ssName] [implements interfaceNameList] 类的访问权限及其属性类定义关键字类名继承某个父
类的关键字 实现接口的关键字 2. 类体构造和初始化新对象的构造方法； 表示类及其对象状态的变量； 实现类及其对象的方法； 进
行对象清除的finalize()方法。 3.1.2 成员变量与局部变量成员变量（类）：在类体中声明的变量，且不属于任何一个方
法时。 局部变量：在方法体中声明的变量以及方法的参数则统称为方法的局部变量。 【例3-1】成员变量示例public class
Apple { public String color; // 公共变量color pub
lic static int num; // 静态变量num public final bool
ean MATURE=true; // 常量MATURE并赋值 public static void main(Str
ing[ ] args) { System.out.println("苹果数量："+Apple.num); Apple
apple=new Apple(); System.out.println("苹果颜色："+apple.color);
System.out.println("苹果是否成熟："+apple.MATURE); }}num是类变量（即静态变量），可
通过类名直接访问2. 局部变量[final] ; 指定局部变量为常量局部变量的参数类型
局部变量的名称【例3-2】局部变量的使用public class Apple { String color="Red";
float price; public String getColor() { return color; }
public float count(){ int num; if(num<0)
return 0; else return pricenum; }成员变量错误语句，
因为局部变量num还没有被赋值就使用public static void main(String[] args) { Ap
ple apple=new Apple(); System.out.println("苹果总价钱："+apple.count
()); }}概念：指该变量在程序代码中的作用区域，在该区域外不能直接访问变量。生命周期：指从声明一个变量并分配内存空间、使用
变量开始，然后释放该变量并清除所占用内存空间的一个过程。3. 变量的有效范围变量的种类：成员变量——类体中声明的成员变量在整个类
中有效。局部变量——在方法内或方法内的复合代码块(方法内部，“{”与“}”之间的代码)声明的变量。【例3-3】变量的有效范围 p
ublic class Olympics1 { private int medal_All=800; public voi
d China() { int medal_CN=100; if(medal_CN<1000) {
int gold=50; medal_CN+=30; medal_All-=130;
} }}成员变量代码块外、方法体内的局部变量代码块的局部变量允许访问本方法的局部变量 允许访问本类的成员变量
3.1.3 成员方法返回值类型 方法名称 { //方法开始标记 } //方法结束标记 方法主体
(参数1，参数2，…… 参数n) 注意：方法体中定义的局部变量的作用域只在方法内部；如果局部变量的名字和类的成员变量名字相同，则
类的成员变量被屏蔽；如果要在方法中使类的成员变量有效，则可以使用this关键字。public class Olympics2 {
private int gold=0; private int silver=0; private int copper=0
; public void changeModel(int a,int b,int c) { gold=a;
// 给类的成员变量赋值 int silver= b; // 使同名类成员变量silver隐藏
int copper= 50; // 使同名类成员变量copper隐藏 System.out.println(“In
changModel:”+“金牌 =”+gold+“ 银牌=”+silver+“ 铜牌"+copper); this.cop
per=c; // 给类成员变量z赋值 }String getModel( ) { return “金牌 = ”+go
ld+“ 银牌 =”+silver+“ 铜牌="+copper;}public static void main( String
args[ ]) { Olympics2 o2=new Olympics2( ); System.out.print
ln("Before changModel:"+o2.getModel()); o2.changeModel(100,100,1
00); System.out.println("After changeModel:"+o2.getModel());}}Bef
or changModel: 金牌=0 银牌=0 铜牌=0gold=100 silver=100 copper=50In chan
gModel: 金牌=100 银牌=100 铜牌=50After changModel: 金牌=100 银牌=0 铜牌=100如果
在方法中对成员变量的值进行了修改，则这种修改将是永久的。gold=0 silver=0 copper=03.1.4 对象的创建
一个对象的生命周期包括三个阶段：对象的创建对象的使用对象的消除 宋波，李晋，李妙妍，张悦创建对象 创建对象 声明 实例化
初始化 类 对象名称 ＝ new 构造方法（参数） public class Point { int x=1;
int y=1; public Point(int x,int y){ this.x=x; this.y=y; }
}//实例化Point类，创建对象ptPoint pt = new Point(2,3); Point pt = new Poi
nt(2,3);3.1.5 对象的使用引用对象的变量objectReference.variableName;调用对象的方法o
bjectReference.methodName(argumentList)【例3-6】对象使用的示例 public clas
s Point { int x=1; int y=1; public void setXY(int x,int y) { …
… } public int getXY() { … … } public static void main(String[
] args) { Point pt=new Point(); pt.x=2;
System.out.println("x与y的乘积为："+pt.getXY()); pt.setXY(3
,2); System.out.println("x与y的乘积为："+pt.getXY());
}}成员变量成员方法声明并创建Point类的对象pt访问对象pt的成员变量x调用成员方法 宋波，李晋，李妙妍，张悦3.1.
6 对象的消除在C++中，程序员要显式地删除不用的对象，即手动释放对象占用的存储空间。 Java提供了垃圾回收(garbage
collection)机制：自动判断对象是否还在使用，并自动销毁不再使用的对象，回收对象所占用的资源。 Java垃圾回收器执行机
制的生命周期3.1.7 方法的重载在同一个类中定义了多个同名而内容不同的成员方法。 classScreen { publi
c void print( int i) { … } public void print( float i) { … }
public void print( int i, String str ) { … } }宋波，李晋，李妙妍，张悦方法重载原则
：参数表必须不同：方法参数的个数不同参数类型不同返回类型、修饰符返回类型【例3-7】方法重载的示例 public class C
alculate { final float PI=3.14159f; public float getArea(float
r) { return PIrr; } public float getArea(float l,float
w) { return lw; } public void draw(int num) { Syst
em.out.println("画"+num+"个任意形状的图形"); } public void draw(String s
hape) { System.out.println("画一个"+shape); }方法重载方法重载宋波，李晋，
李妙妍，张悦 public static void main(String[] args) { Calculate c=ne
w Calculate(); //创建Calculate类的对象 float l=20; float w=40; Sys
tem.out.println("求长为"+l+"宽为"+w+"的矩形面积是："+c.getArea(l,w)); float r
=6; System.out.println("求半径为"+r+"的圆形面积是："+c.getArea(r)); int n
um=8; c.draw(num); c.draw(“矩形”); }}通过传递的参数判断调用哪个方法通过传递的参数判
断调用哪个方法3.1.8 关键词this用来指向对象自身 用来访问当前对象的数据成员;用来访问当前对象的成员方法;重载构造方法
时，用来引用同类的其他构造方法。宋波，李晋，李妙妍，张悦【例3-8】this关键字的使用 public class Fruit
{ String color="绿色"; double price; int num;……public double count(
double price, int num) { this.price=price; this.n
um=num; return pricenum; }……}成员变量将参数值赋值给成员变量，即指向对
象自身。宋波，李晋，李妙妍，张悦3.1.9 类的构造方法功能：初始化类的成员变量特点：名称必须与类名相同不能有返回值必须用ne
w自动调用宋波，李晋，李妙妍，张悦【例3-9】在类Apple中定义两个构造方法 public class Apple { pr
ivate int num; private double price; public Apple() {
num=10; price=2.34; } public Apple(int num,double price) { this
.num=num; this.price=price; }…… public static void main(String
args[]){ Apple a1=new Apple(); Apple a2=new Apple(50,3.15)
…… }}参数化构造方法宋波，李晋，李妙妍，张悦2. 缺省构造方法如果在类定义中无构造函数，在编译时可缺省加入构造方法
。如： public Apple( ) { };一旦在类中有一个自己声明的构造函数，则缺省的构造函数将不被加到源程序中。宋波，
李晋，李妙妍，张悦3. 构造方法的重载功能：使类对象具有不同的初始值，为对象的初始化提供方便。可以使用this调用重载的构造方法
。宋波，李晋，李妙妍，张悦【例3-10】对类Apple的构造方法进行重载 class Apple { private Stri
ng color; private int num; public Apple(String c, int n) { colo
r = c ; num = n; } public Apple( String c) { this(c,0); }调用两
个参数的构造方法宋波，李晋，李妙妍，张悦class Apple { private String color; private
int num; …… public Apple( String c) { this(c,0); } public Ap
ple( ) { this("Unknown"); }}调用一个参数的构造方法宋波，李晋，李妙妍，张悦class App
le { private String color; private int num; …… public String
getColor() { return color; } public int getNum() { return num
; } }宋波，李晋，李妙妍，张悦public class AppleDemo { public static void ma
in(String[ ] args) { Apple applee = new Apple(); System.out.pri
ntln(“苹果颜色: ”+e.getColor()); System.out.println(“苹果数量: ”+
e.getNum()); }}调用无参数：this(“Unknown”); —〉1个参数：this(c,0);—〉2个参数的构造方
法宋波，李晋，李妙妍，张悦3.2 隐藏与封装封装访问控制package和import宋波，李晋，李妙妍，张悦3.2.1 封
装封装，是指将对象的数据与操作数据的方法相结合，通过方法将对象的数据与实现细节保护起来。 在类的定义中设置访问对象属性及方法的权限
，来限制该类对象及其他类的对象的使用范围。提供一个接口来描述其他对象的使用方法。宋波，李晋，李妙妍，张悦3.2.2 访问控制私
有的——以private修饰符指定；保护的——以protected修饰符指定；公开的——以public修饰符指定；默认的，也称为d
efault或package——不使用任何修饰符指定。宋波，李晋，李妙妍，张悦表3-1：4种访问权限及其含义可否直接访问
同一个 同一个 不同包中的 任何 控制等级 类中 包中
子类中 场合private Yesdefault Yes Yesp
rotected Yes Yes Yespublic Yes Yes
Yes Yes宋波，李晋，李妙妍，张悦1. private修饰符其成员只能在所在类的内部使
用，在其他的类中则不允许直接访问。同一个类的不同对象之间可以访问对方的private成员变量和方法；访问控制是在类的级别上，而不是
在对象的级别上。宋波，李晋，李妙妍，张悦宋波，李晋，李妙妍，张悦class Parent { private int
privateVar; public Parent( int p) { privateVar=p;
} boolean isEqualTo(Parent anotherParent) { if (t
his. privateVar==anotherParent.privateVar) return true
; else return false; }}当前对象实例的成员变量与方法的参数传递的
另一个对象实例的成员变量是否相等？宋波，李晋，李妙妍，张悦public class PrivateDemo { publi
c static void main(String args[ ]) { Parent p1=new Parent(
20); Parent p2=new Parent(40); System.out.println(p1.is
EqualTo(p2)); }}宋波，李晋，李妙妍，张悦2. default如果一个类没有显式地设置成员的访问控制级别，则
说明它使用的是默认的访问权限，称为default或package。 允许被这个类本身，或者相同包中的其它类访问其default成员
。 构造方法设置为default权限时，则除这个类本身和同一个包中的类以外，其他类均不能生成该类的对象实例。宋波，李晋，李妙妍，
张悦宋波，李晋，李妙妍，张悦3. protected修饰符允许类本身、它的子类、以及同一个包中其余的类访问这些成员。宋波，李
晋，李妙妍，张悦package p1; class Parent { protected int protectedVar;
protected void protectedMethod( ) { System.out.println(“I
am protectedMethod"); } } 宋波，李晋，李妙妍，张悦package p1; class Perso
n { void accessMethod() { Person p = new Person(); p.pr
otectedVar = 100; p.protectedMethod(); }} 由于Person类与Parent
在同一个包中所以，可以创建它的对象，并实现访问。宋波，李晋，李妙妍，张悦package p2; import p1.; cla
ss Child extends Parent { void accessMethod(Parent p, Child c)
{ p.iamprotected = 10; c.iamprotected = 10; // 子类 p.pr
otectedMethod(); c.protectedMethod(); // 子类 }} X由于Child与父类P
arent不在同一个包中，只能通过子类Child的对象来实现访问√X√宋波，李晋，李妙妍，张悦4. public修饰符带有pu
blic的成员可以被所有的类访问。 一个成员只有在被外部对象使用后不会产生不良后果时，才被声明为public。 宋波，李晋，李妙
妍，张悦3.2.3 package和import程序员可以将一组相关的类与接口包裹在一起形成一个包(package)。易于确定包
中的类是相关的，根据功能可找到相应的类。防止类命名混乱。控制包中的类、接口、成员变量和方法的可见性。 宋波，李晋，李妙妍，张悦1
. package语句指定程序中的类属于一个哪个包：package pkg1[.pkg2.[pkg3…]]; 包定义语句在每个
源程序中只能有一条，即一个类只能属于一个包;包定义语句必须在程序的第一行(之前可有空格及注释);包名用“.” 分隔。宋波，李晋，
李妙妍，张悦【例3-13】利用package关键词，将类Circle打包到 com下的graphics包中。package c
om.graphics;public class Circle { final float PI=3.14159f; //
定义一个常量PI public static void main(String[] args) { System.out
.println("画一个圆形！"); }}宋波，李晋，李妙妍，张悦comgraphicspackage com.grap
hics;该Java程序所定义的类保存的路径为：C:\ mypkg\com\graphicsclasspath=.;c:\mypk
g包分隔符相当于目录分隔符，包存储的路径由包根路径加上包名指明的路径组成；包的根路径由CLASSPATH环境变量指出。宋波，李晋
，李妙妍，张悦编译和生成包编译之后拷贝javac Circle.java→Circle.class将Circle.class复制
graphics子目录下简化的编译命令javac -d C:\mypkg Circle.java1、生成C:\mypkg\c
om\graphics；2、将Circle.class保存到该子目录下。宋波，李晋，李妙妍，张悦宋波，李晋，李妙妍，张悦2.
import语句功能：import语句告诉编译器要使用的Java类所在的位置；注意,包名也是类名的一部分。宋波，李晋，李妙妍，
张悦将package 引入源程序，格式： import 包名.； import 包名. 类名；impor
t 语句必须在源程序之前，在package 声明之后，Java程序的结构： [package …..] // packa
ge .; [import ….] // import java.lang.; [类声明…]宋波，李晋，李妙
妍，张悦3.3 类的继承与多态类的继承方法的重写运行时多态对象类型的强制转换Object类宋波，李晋，李妙妍，张悦3.3.1
类的继承宋波，李晋，李妙妍，张悦继承其他类的类叫子类，被继承的类叫做超类（父类）。 继承的特点 层次结构 子类继承
父类的属性和方法 宋波，李晋，李妙妍，张悦例3-15：宋波，李晋，李妙妍，张悦实现步骤：步骤１：编写父类步骤２：编
写子类，使用关键字extends继承父类宋波，李晋，李妙妍，张悦【执行结果】动物需要吃食物鸟会飞翔鸟有：羽毛宋波，李晋，李妙妍
，张悦2. 单继承Java是单继承的，即只能从一个类继承，extends后类名只能有一个。单继承的优点：代码更可靠；可以用接口弥
补，用一个类实现多个接口，达到多继承效果。宋波，李晋，李妙妍，张悦3. super关键字super可用于访问父类中定义的属性和
成员方法；super可用于在子类构造方法中调用父类的构造方法；super的追溯不仅限于直接父类。宋波，李晋，李妙妍，张悦【例3-
16】使用super调用父类构造方法class Animal { boolean live=true; String skin
=" "; public Animal(boolean l,String s) { live=l; skin=s;
}}宋波，李晋，李妙妍，张悦class Bird extends Animal { public Bird(boolean l
,String s) { super(l,s); }}public class Zoo { public static
void main(String[] args) { Bird bird=new Bird(true,"羽毛"); Sys
tem.out.println("鸟有："+bird.skin); }}通过super调用父类的构造方法宋波，李晋，李妙妍，张
悦注意：子类构造方法体的第一句通常要调用父类的一个构造方法。此时，如果不使用super指定，则将调用默认的父类构造方法(即不带参数
的构造方法)。如果在父类中没有无参构造方法，则将产生编译错误。宋波，李晋，李妙妍，张悦子类中父类成员的隐藏子类隐藏父类的成员当子
类的成员变量与父类的成员变量同名时；当子类的成员方法与父类的成员方法具有相同的名字、参数列表、返回值类型；宋波，李晋，李妙妍，张
悦“隐藏”的含义通过子类对象调用子类中与父类同名的变量和方法时，有效的(操作)是子类中定义的变量和方法。如果要在子类中访问父类中被
隐藏的成员变量或方法，要使用关键词super。 宋波，李晋，李妙妍，张悦3.3.2 方法的重写在子类中对从父类继承的方法进行改
造，称为方法的重写。子类中重写方法必须和父类中被重写方法具有相同的方法名、参数列表和返回值类型子类中重写方法的访问权限不能缩小子类
中重写得方法不能抛出新的异常 宋波，李晋，李妙妍，张悦重写【例3-18】重写的示例宋波，李晋，李妙妍，张悦public cla
ss Zoo { public static void main(String[] args) { Dog dog=new
Dog(); System.out.println(“执行dog.cry()语句时的执行结果是："); dog.cr
y(); Cat cat=new Cat(); System.out.println(“执行cat.cry()语句时的
执行结果是："); cat.cry(); }}【执行结果】执行dog.cry(); 语句时地执行结果是：狗
发出汪汪声！执行cat.cry(); 语句时地执行结果是：猫发出喵喵声！宋波，李晋，李妙妍，张悦3.3.3 运行时多态多态性(
Polymorphism)指在一个程序中相同名字的成员变量和方法可以表示不同的实现。 方法重载：静态多态性，或称编译时多态；方法重
写(覆盖)：动态多态性；变量覆盖：子类可以隐藏与父类中的同名成员变量。宋波，李晋，李妙妍，张悦1. 上溯造型通过引用子类的实例
来调用父类的方法，从而将一种类型(子类)对象的引用转换成另一种类型(父类)对象的引用。Animal a1=new Parrot()
;Animal a2=new Dog();Animal a3=new Cat();宋波，李晋，李妙妍，张悦2. 运行时多态通过
一个父类变量发出的方法调用：该方法在父类中的实现该方法在某个子类中的实现只能在运行时，根据该变量指向的对象类型确定宋波，李晋，李
妙妍，张悦宋波，李晋，李妙妍，张悦3.3.4 对象类型的强制转换下溯造型 将父类类型的引用转换为子类类型，称为下溯造型；下溯造
型不一定是安全的，需要进行类型检查。宋波，李晋，李妙妍，张悦1. instanceof运算符<引用类型变量> instanc
eof <引用类型>boolean表达式宋波，李晋，李妙妍，张悦class Cat extends Animal { }c
lass Dog extends Animal { }public class TestInstanceof {public v
oid doSomething( Animal a) { if (a instanceof Cat) { System
.out.println("This is a Cat"); } ……}使用instanceof方法测试接收的对象是否是C
at类或其子类宋波，李晋，李妙妍，张悦2. 强制类型转换(SomeClass) aObjectVariable父类弱、子类强，
指向父类的引用不能直接按子类引用，必须要强制类型转换后才能作为子类的引用使用。强制转换之前，一般先用instanceof对对象的类
型进行测试。宋波，李晋，李妙妍，张悦class Animal { String skin;}class Bird extend
s Animal { String skin="羽毛"; public String getSkin() { retur
n skin; }}public class Casting { public void someMethod(Animal
a) { System.out.println(a.getSkin()); if(a instanceof Bird){
Bird b=(Bird)a; System.out.println(b.getSkin()); } }宋
波，李晋，李妙妍，张悦3.3.5 Object类Object定义了所有对象都需要的状态和行为。例如：对象之间的比较将对象转换为字
符串等待某个条件变量当某条件变量改变时通知相关对象返回对象的类宋波，李晋，李妙妍，张悦1. equals方法equals方法用
于判别某个指定对象与当前对象（调用equals方法的对象）是否等价；“数据等价”：两个数据的值相等引用类型数据比较的是引用基本数据
类型比较值宋波，李晋，李妙妍，张悦equals与“==”运算符equals( )方法只能比较引用类型；“==”可以比较引用和基本
类型；equals( )方法对File、String、Date及封装类(Wrapper Class)，是比较类型内容，而不考虑引用
的是否是同一个实例；宋波，李晋，李妙妍，张悦public class TestEquals { public sta
tic void main(String[ ] args) { String s1 = new String ("Hel
lo"); String s2 = new String ("Hello"); if ( s1 == s2 ) {
System.out.println("s1==s2"); } else { System.
out.println("s1!=s2"); } // 输出： s1!=s2宋波，李晋，李妙妍，张悦 if ( s1.e
quals(s2) ) { System.out.println(“s1 is equal to s2"); } else
{ System.out.println(“s1 is not equal to s2"); } // 输出： s1 i
s equal to s2 s2 = s1; if ( s1 == s2 ) { System.out.println(“
s1==s2"); } else { System.out.println(“s1!=s2"); } }
// 输出： s1==s2}宋波，李晋，李妙妍，张悦2. toString方法Object类中实现的toString( )方法
是返回当前对象的类型和内存地址信息。但在一些子类(如String、Date等)中进行了重写。在用户自定义类中通常都将该方法重写，以
返回更适用的信息。宋波，李晋，李妙妍，张悦3.4 数组一维数组多维数组数组的复制宋波，李晋，李妙妍，张悦Java中数组的分类
宋波，李晋，李妙妍，张悦3.4.1 一维数组定义：type arrayName[ ] 或type[ ] a
rrayName类型(type)可以为Java中任意的数据类型，包括简单类型和复合类如：int intArray[ ]；
Date dateArray[];宋波，李晋，李妙妍，张悦注意：在声明数组时不能指定其长度：int a[5]
; // 不合法原因：声明数组，只是在内存中为该类型数组变量分配引用空间，并没有为数组中每个元素分配数据空间。宋波，李
晋，李妙妍，张悦2. 数组的创建arrayName = dataType [arraySize3. 数组的长度arrayNam
e.length;宋波，李晋，李妙妍，张悦4. 静态初始化声明并创建了一个长度为 3 的double型的数组double d
[ ]={ 3.14, 2.718, 10.0 };String s[ ]={“Hello", “my", “Java"};声明
并创建了一个长度为 3 的 String 型的数组d[0]=3.14；d[1]=2.718；d[2]=10.0s[0]= "Hel
lo" s[1]= "my" s[2]= "Java"静态初始化：在声明一个数组的同时，对该数组中每个元素进行赋值宋波，李晋
，李妙妍，张悦5. 动态初始化在声明(创建)一个数组类型对象时，只为其分配空间，而不同时对其中的各元素赋值。new dataT
ype[arraySize];宋波，李晋，李妙妍，张悦简单类型：int a[ ];a=new int[3];a[0]=1;a
[1]=2;a[2]=3;声明数组变量a，为其分配定长的引用空间(值为null)1. 创建一个含有3个元素的int型数组对象；2.
为a分配3个int型数据空间3. 将3个元素值初始化为0 nulla0x2a567ba0x2a567b宋波，李晋，李妙妍，张悦
引用类型：nulls0x2473c4snullnullnull0x2473c4String s[ ];s=new String
[3];S[0]S[1]S[2]地址值宋波，李晋，李妙妍，张悦引用类型：0x2473c4s0x478b520x2473c4s[0
]=new String(“Hello");s[1]=new String(“my");s[2]=new String(“Java
");S[0]S[1]S[2]0x478b680x478b3c“my"“Java"0x4d78c9宋波，李晋，李妙妍，张悦6.
数组元素的引用数组元素的引用方式为： arrayName[index]index为数组下标，它
可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length指明它的长度。宋波，李晋，李妙妍，张悦【例3-24】int
[ ] anArray; anArray = new int[10]; for (
int i = 0; i < anArray.length; i++) { anArray[i] = i; Sys
tem.out.print(anArray[i] + " ");}声明数组创建长度为10的数组数组的长度为每个数组元素赋值宋波，
李晋，李妙妍，张悦3.4.2 二维数组定义： type arrayName[ ][ ]； 或
type[ ][ ] arrayName;类型(type)可以为Java中任意的数据类型，包括简单类型和复合类 例如：
int intArray[ ][ ]； Date[ ][ ] dateArray;宋波，李晋
，李妙妍，张悦示例：int a[ ][ ] = new int [4][5];将创建一个有 4 个数组的数组，每个数组中又有 5
个整数，即 4 行 5 列的整数矩阵。宋波，李晋，李妙妍，张悦静态初始化int a[ ][ ] = {{2,3}, {1,5}
, {3,4}};a[0][0]=2 a[0][1]=3a[1][0]=1 a[1][1]=5a[2][0]=3
a[2][1]=42 31 53 4宋波，李晋，李妙妍，张悦静态初始
化int a[ ][ ] = {{1,2}, {3,4,0,9}, {5,6,7}};a[0][0]=1 a[0][1]=
2a[1][0]=3 a[1][1]=4a[1][2]=0 a[1][3]=9a[2][0]=5 a[2][1
]=6a[2][2]=71 23 4 0 95 6 7宋波，李晋，李妙妍，张悦二维数组的动态
初始化int a[ ][ ];a=new int[3][ ];a[0]=new int[2];a[1]=new int[4
];a[2]=new int[3];1 23 4 0 95 6 7宋波，李晋，李妙妍，张悦
正确的说明示例：int a1[ ][ ] = new int [2][3];int a2[ ][ ] = new int [2][
];int a3[ ][ ] = new int [4][6];将创建一个有 2 个数组的数组，每个数组中又有 3 个整数，即 2 行 3 列的整数矩阵宋波，李晋，李妙妍，张悦错误的说明示例int errarr1[2][3];不允许静态说明数组数组维数说明顺序应从高维到低维数组维数的指定只能在new运算符之后int errarr2[ ][ ] = new int [ ][4];int errarr3[ ][4] = new int [3][4];宋波，李晋，李妙妍，张悦0x2473c4a0x478b520x2473c4int a[ ][ ];a=new int[3][3];a[0]a[1]a[2]0x478b680x478b3c0x4d78c90a[0][0]a[0][1]a[0][2]000a[2][0]a[2][1]a[2][2]00宋波，李晋，李妙妍，张悦【例3-25】int[ ][ ] aMatrix = new int[3][ ];将创建一个有 3 个数组的数组，每个数组中又有 0~a[i].lengh-1个整数，即 3 行0~a[i].lengh-1列的整数矩阵宋波，李晋，李妙妍，张悦for(int i=0;i
|
|
