ch3 4zh

Machine Translated by Google
课程地图
第一章：
概述
第 2 章：
类和对象
第 3 章：
数组和字符串
第 4 章：
继承和多态
第 5 章：
抽象类和接口
第 6 章：
例外情况
面向对象程序设计课程 0
第3章：
数组和字符串
1. 表格
1.1.陈述
//相当于int tab[];整数[]标签；
颜色 rgb_cube [ ][ ][ ] ;
评论
如果[ ]跟在类型之后，
则所有声明的变量都是数组；
如果[ ]跟在变量名后面，
则只有变量是数组：
int [] firstArray, secondArray; float thirdArray[ ],变量；
⇒单个变量不是数组。 2个
1.2.创建和初始化
整数 [ ] 向量 = {1, 2, 3, 5, 7, 7+4};
rgb_cube = 新颜色[256][256][256]；
制表符 = 新整数 [42]；
选项卡[0] = 3；
3个
默认值：
基本类型元素数组的情况：每个元素根据其类型初始化： 0表示数字， false表
示布尔值， null表示字符串，...。
对象元素数组的情况：
每个元素都初始化为null
访问从0到size ‑ 1的索引
4个
1.3.访问元素：
访问已创建数组的元素： tab [ i ]
下图是表示访问 tab[i] 的正确方式：
5个
1.4.数组的有效大小
由于length属性，
可以知道制表符的长度：
array_name.length示
例：
for (int i = 0; i < tab.length; i++)
{ int元素 = tab [ i ]; ... }
1.5.指标控制
在 Java 中，
总是会检查索引的有效性。
在评估像 tab[i] 这样的框访问表达式时，
检查i可以检测到两个常见错误并引发异常：
6个
‑ NullPointerException，
表示tab = null，
即变量 tab 是无效引用 ⇔变量 tab 已声明，
但尚未创建相应的数组，
‑ ArrayIndexOutOfBoundsException，
表示不满足条件(0 <= i < tab.length) 。
7
1.6.表格的一些补充：
数组被认为是一个对象
数组总是通过引用处理（当通过一个方法时）
数组的声明仅将其标识符（或其引用）
与值null相关联
8个
数组的大小在新原语创建时指示
可以基于原始类型或构造类型（类或数组）
构造数组
A table that no longer referenced is eliminated by the garbage collector‑ A table that no longer referenced is eliminated by the garbage
collector不再引用的表
9
1.7.方法的参数和结果
数组可以作为参数传递给方法。
更确切地说，
它是通过它的参考
要通过对方法的引用传递原始类型的变量，
我们将其声明为单个元素的
数组
一个方法可以返回一个数组。
然后我们恢复对结果表的引用
10
1.8.申请的运营商
绘画
您可以应用运算符：
=、== 和 !=。
操作涉及的是表格的引用
11
1.9.多维数组
JAVA 允许管理多维数组 ⇒数组的数组（数组的⋯⋯）
诠释垫 [ ] [ ]; // mat 表示具有两个索引的 int 数组 int[] mat[]; //

mat 表示具有两个索引的整数数组 int [ ][ ] mat;// mat 表示具有两
个索引的整数数组
一个有 2 个索引的表
⇔
一个单索引数组，
其元素是 [references to] 单索引数组，
其元素是整数。
12
13
示例：
int [][]
t=new int[5][]； for(int i=0;
i<t.length;i++) t[i]=new int[5 ‑ i];
for(int i=0; i<t.length;i++) for(int
j=0; j<t[i].length;j++) t[i][j] = i+j;
[0] [1] [2] [3] [4]
t[0] 0 1个 2个 3个 4个
t[1] 1个 2个 3个 4个
t[2] 2个 3个 4个
t[3] 3个 4个
t[4] 4个
14
1.10.对象数组
从类声明的数组，
包含对相关类对象的引用。
每个数组元素代表对对象的引用。
15
公开课StudentTest
{ public static void main(String[] args)

{
学生;
学生 t[ ] = 新学生 [2]; // 两个元素数组
的声明
t[0] = new Student(34, ali ,2, khaki ); // 新对象
t[0].changeColor( gray );布尔 b= t[0] instanceof 学生；
t[1] = t[0]； // 同一对象的两个引用e=t[1]; // 我们终于有了一个对
象}
} 16
2. 字符串
2.1.坦克桌
表示形式1：
以char数组的形式。
每个字符都放在表格的一个单元格中，
不使用特殊字符，
例
如 \0
缺点：
无法使用
标准字符串操作。
⇒很少使用的表示法
表示 2 ：
作为String类的对象
17
例子：
类 ArrayChar
{ public static void main(String[] arg)
{字符 [ ]数组；
数组 =
新字符 [4];数组[0] = 我 ;数组
[1] = A ;数组[2] = V ;数组
[3] = A ; System.out.println(数
组); //显示：
JAVA
}
}
18
2.2. String类 JAVA在其库（API）

中提供了String类，
功能非常丰富
String 类提供字符串常量对象。 ⇔用于处理不可修改的字符串
声明：
//第一个声明可能
String firstname = new String( Pierre );
鉴于其密集使用
//非常常用的第二个声明
String firstname = Pierre ;
19
String 对象是常量：
一旦设置，
它的值就不能改变。
另一方面，
它可以被分配一个新的字符串。
String msg = 你好！ ;
//然后我们可以给它分配另一个字符串
msg = 新消息 ;
⇒字符串“你好！”
被遗忘并且 msg 对象指向
在另一个频道
20
字符串连接：
第一种情况：
使用concat方法
字符串 s3 = s1.concat(s2);
第二种情况：
使用加号 + 进行连接：
“和 “
字符串词=消息+ + “然后离开”；
第三种情况：
使用符号 +=
字符串词 += s1;
21
class TestString
{ public static void main(String [] args) { //
创建和初始化String ch1,ch2,ch3;
ch1= 编程 ;通道2=通道1；
System.out.println( ch1: +ch1);//
编程System.out.println( ch2:
+ch2);//编程// JAVA中的拼接ch1+= ; //创建一个新对象
System.out.println( ch1: +ch1);//JAVA编程

System.out.println( ch2: +ch2);//编程
扫描仪 s = 新扫描仪 (System.in); ch3 =

s.nextLine(); //另一个新对象}
22
字符串比较：
该声明：
if (str1 == str2) ... // 没有错误
⇒不比较两个字符串是否相等，
但如果str1和str2指向同一个对象则指向同一个对
象。
23
字符串内容的比较： if (str1.equals(str2)) ...
或者再次： str1.compareTo(str2)； CompareTo

返回值：
‑如果两个字符串相等则为 0，
如果 str1 <
str2 则为 ‑ < 0，
如果str2 < str1 则为>0 。
24
评论：
equalsIgnoreCase方法与 equals 的作用相同
但不考虑大小写的差异（大写和小写）
禁止使用运算符 >、
>=、
<、<=
25
字符串的长度： length()
例如， msg.length() 。
访问字符串中的一个字符： charAt(index) ⇒ 从指定的字符串中

返回指定的字符。
例如， msg.charAt(1) 。
注意：
index 参数的值可以介于0和msg.length() ‑ 1 之间。
26
杂项转换
尽管不能修改字符串的内容，
但可以通过创建新字符串来执行转换。
toLowerCase和toUpperCase方法分别用于获取小写和大写的字符串。
trim方法可以获取开头或结尾没有空格的新字符串。
replace(oldChar, newChar) 方法用于将字符串中的所有 oldChar 字符替换为

newChar字符。
27
字符、
数组、
整数等的转换到字符串
valueOf：
将一个字符、
字符数组和数值转换成字符串。
这些方法具有相同的名称，
但提供给它们的参数类型不同（char、
char[]、
double、
long、
int、
float 等）
字符串值（布尔值 b）
字符串 valueOf(char c)
字符串值（字符[]数据）
字符串值（加倍）
字符串 valueOf(float f)
字符串 valueOf(int i)
StringvalueOf(long l) 28
导入java.io.*；
公共课测试{
public static void main(String args[])
{ 加倍 = 102939939.939;
布尔 b = 真；
长 l = 1232874； char[]arr =
{ a , b , c , d , e , f , g };
System.out.println( 值: + String.valueOf(d)); System.out.println( 值：
+String.valueOf(b));
System.out.println( 值： +String.valueOf(l)); +String.valueOf(arr));
System.out.println( 值：
} }
29
提供的其他方法
int indexOf(char ch)：

返回字符串中第一次出现 ch（视为字符）
的索引
（或 –1）
int indexOf(String str)：

返回str在字符串中第一次出现的第一个字符的索引（或–1）
30
2.3.字符串缓冲区类
提供可编辑的字符串对象：
可编辑的内容
比字符串类型更灵活
+（和 +=）
运算符禁止用于此类的对象
创建： 3个可能的构造函数：
public StringBuffer()：
一个大小为 16 的空字符串，
因为public
StringBuffer(int length) ：
一个空字符串，其容量由 length 指示。
public StringBuffer(String str)：
接收str参数的字符串。链的容量是
16 加上 str 的长度。
31
StringBuffer 类提供的其他特性：
int length() ：
返回字符串的长度
void setlenght (int newLong)：

允许您指定 StringBuffer 的长度。
int capacity() ：
返回关联数组的大小
StringBuffer append(char c)：

在字符串末尾追加字符c
StringBuffer append(String str)：

将str对象的内容追加到字符串的末尾
StringBuffer append(char str[])：

将str数组的内容追加到字符串的末尾
32
StringBuffer insert(int i, char c)：

在字符串的位置i插入字符c
StringBuffer insert(int i, String str)：

在字符串的位置i插入str对象的内容
StringBuffer reverse() ：
反转字符串
注意： append
方法隐藏了多个同名方法，
允许添加 char、
char[ ]、
double、
float、
int、
long 和 String
表达式。
33
例子：
StringBuffer st = new StringBuffer(); st.append( 课程 );
st.append( );
st.append( 从 );
st.append( Java );
st.insert(9, HTML 和 );
⇒ StringBuffer 是动态演变的。 ⇒如果其内容的长度增加，

分配的内存空间会自动增加。
34
课程地图
第一章：概述
第 2 章：
类和对象
第 3 章：
数组和字符串
第 4 章：
继承和多态
第 5 章：
抽象类和接口
第 6 章：
例外情况
35
第 4 章：
继承与多态
1.继承的概念
1.1.基本原则
继承的概念指定类之间的专业化/泛化关系（文档：书籍，
期刊，....../人：
学生，
员工......）
当D类继承自B类时：
D具有B的所有特征以及 D 特有的其他特征
D是B的特化（特例）
37
B是D的推广（一般情况）
D被称为派生（子）
类
B称为基类（母类或超类）
从 D 实例化的任何对象也被视为 B 类型的对象
从 B 实例化的对象不一定是 D 类型的对象
一个类可以继承多个类：
多重继承
（示例：
学生和员工同时出现）
一个基类可以被多个类继承
（例如：
文档）
38
1.2.兴趣
易于设计_
代码编写的优化：
通过将类之间的共同特征分组到一个类中。
易于扩展或添加新类，
尤其是在设计良好的类层次结构的情况下
使信息系统的建模更接近真实案例。
39
2. JAVA中的继承
继承由扩展（extends ）
的概念表示
D类可以定义为另一个B类的扩展
注意： ‑ 类型 B 的已声明对象引用可以引用类型 D 的对象 ‑ 反之则为假
没有多重继承： =>可能有接口
所有类都继承自 JAVA API 的 java.lang 包中定义的 Object 类（即使没有

指明）。
对象只有方法
任何对象都被认为是 Object 类型
句法：
[访问修饰符] class DerivedClass extends

基类{
⋯⋯
}
类人{
私有字符串名称；
私有字
符串名字；
私有字符串地址；
public void print()

{ System.out.println
( 名字是： + lastname+ \n 他的名字是： + firstname+ \n 他的地
址是： +address);
} public void changeAddress (String addr)

{address = addr;}
}
类学生扩展人{
私人整数；
私有字符串文件；
私人 int 级别；
public void newLevel(int n) {level =

n;} public void
changeLine (String f) {line = f;}
2.1.定义派生类构造函数
基类构造函数负责初始化继承的属性，
由super()指定
基类构造函数由super( )的参数标识
基类构造函数调用必须是派生类构造函数中的第一条语句
如果不调用 super() ，
将会隐式调用基类的无参数构造函数。
⇒不带参数的构造函数调用：
‑由程序员实现的一个（在这种情况下是必需的
有一个没有参数的构造函数）
‑如果程序员没有定义构造函数，
则为基类的默认值，
class Person
{ public Person
(String n, String p, String addr) { name = n, first name = p;
地址=地址；}
⋯⋯
类学生扩展人
{ public Student (String n, String p, String addr, int m, String f, int level)
{ super(n,p,adr);注册号=m；
死= f;级别=级别； }
⋯⋯
} 面向对象程序设计课程 46
2.2.访问继承成员
（在派生类中）
第一种情况：
在基类中声明为私有的继承成员（属性和方法）：
尽管是其
描述的一部分，但派生类无法访问。
第二种情况：
在类中声明受保护的继承成员2种情况：
在类中声明受保护的继承成员
Base：
Derived类授权的访问权限（Access reserved for Base：
Derived
类授权的访问权限（为所有级别的所有派生类保留访问权限，也为同一个
包的类保留访问权限）
继承的成员由super.member指定（如果允许访问）
人类_
{受保护的字符串名称；
私有字符
串名字；
私有字符串地址；
⋯⋯
public String getFirstname()

{return firstname;} public
String getAddress() {return
address;}
⋯⋯
面向对象程序设计课程 48岁
类学生扩展人
{
⋯⋯
public String toString()

{ return ( 学生的名字
是： +super.name+
\n 他的名字是： +super.getPrenom()+ \n 他的
地址是： +super.getAddress()+ \n 他的注册号
是： +registration+ \n of the sector +文件+”
和
级别：
“+级别）；
}
⋯⋯
3.重写继承的方法
继承的方法可以在派生类中被重写
重新定义包括保留方法的标题并提出不同的代码
重定义方法时，可以通过super.name_method()调用旧版本（基类的），
并将其替换为程序员认为合适的新代码
super仅在override的代码中需要调用基类方法
如果继承的方法被覆盖，
则只有新版本是派生类描述的一部分
注意：如果方法定义在类级别
derived是不同的类型，
或者不同的参数，
那么就是在继承自基类的方法
上增加了一个新的方法
如果通过派生类的方法完全保留标头：
可以根据以下规则更改访问修饰符：
从最受限到最广泛。
对象方法不能被类方法覆盖
类学生扩展人
{
⋯⋯
public void display()

{ super.display();
System.out.println( \n他的报名号是： +registration+ \n所属部
门 +course+ 级别： +level);
}
public String toString()

{return ( 学生的名字是： +super.lastname+ \n 他的名
字是： +super.getFirstname()+ \n 他的地址
是： +super.getAddress( )+ \n他的报名号
是： +registration+ \n of the sector +course+ 和
级别： “+级别）；}
} 面向对象程序设计课程 52
4.属性的重新声明
可以在 Base 类和 Derived 类中声明具有相同名称的属性。
访问类型和修饰符也可能不同。
为了将属性与基类区分开来，使用了以下方法之一：在它前面加上super在它

前面加上对相关实例((baseClass)this) 的引用。
实际上，
派生类的实例隐藏了
基类的实例
注意：
无论如何，
这是一个要避免的解决方案，
因为它会带来很多歧义，
尤其是在有
多个继承级别的情况下。
示例： B类
{ protected
int x, y;公
共无效显示（）
{ System.out.println( x= +x+ y= +y); }

}
HB 类扩展 B
{ 私人双x;私有整数y,
z; public HB(double
a,int b) { //super(); x=a;z=b; }
public void display() { //

super.display();
System.out.println(
basic x = +((B)this).x+ basic y = +super.y+ x= +this.x+
“
y= +y+ z= +z );
}
} public class THB

{ public static void
main(String[] args)
{ HB hb = 新 HB(6.5,13);
hb.display(); }
5. final类和方法
JAVA允许通过用final修饰符声明类来禁止类的继承
JAVA允许禁止重定义一个方法（如果是JAVA允许禁止重定义一个方
法（如果是继承的）通过用final修饰符声明它
6.对象引用
基类的引用可以指定派生类的对象
casting operator can be used to convert a casting operator可用

于将声明的基类类型引用转换为派生类类型引用（对于派生类的对象）
例子：
public class StudentTest

{ public static void main
(String [] args)
{ 学生;人p1，
p2； p1 = new
Student( Favennec , Lucie , Adr1 ,12, LFIG ,2); e=（学生）
p1； e.显示（）； // p1.display(); p2=e； // p1, p2 和 e 指定同一个对象 }
7. 类成员的可见性规则
可见性规则在类级别到对象级别工作。
如果这个对象属于同一个类，
一个对象
可以完美地访问另一个对象的私有方法
The inherited member is of public modifier: 继承成员是public modifier:
所有类的所有方法都可以访问继承的成员，
而不管它们的位置
继承的成员具有私有修饰符：
基类的方法（定义相关属性的同一类的一部分）
是唯一允许访问继承成员
的方法
继承的成员是受保护的修饰符：
访问被授予：基类的方法（相
关属性定义的同一类的一部分）派生类的方法，
无论其位置如何同一包的
方法
继承的成员是修饰符友好的：
访问被授予：
基类的方法（定义
相关属性的同一类的一部分）
同一包的方法
同一包中的派生类同一个包中的另一个包中的派生类类

同班
访问：类其他包
裹
观众 X X X X X
保护保护 XX XX XX XX
默认（友好） X X X
私人的 X
8.多态性
8.1.多态方法
多态方法是在超类中声明并被子类超类覆盖并被子类覆盖的方法
多态方法使得预测对不同性质的对象的相似操作成为可能
final 方法不能被覆盖，
因此不是多态的
8.2.多态性的定义
这涉及在不知道相应对象的性质的情况下调用（调用）
方法
该调用是从与相应对象或其基类类型相同类型的引用进行的（您可以返回到其
基类的所有级别）
得益于多态性，
相同的写法可以对应不同的方法调用
示例：Aa=
meth.creationObject(); //
meth 返回类型 A 或派生自 A 的类型的对象 am(); //可以调用A或A的任
何子类的方法m()
8.2.1.多态性机制
多态性是通过称为“后期绑定”
的动态机制实现的
然后确定将要执行的方法：
只在运行时，
不在编译时
通过接收消息的对象的真实类型而不是通过指定它的引用的类型（管理指
向对象类描述的指针）
8.2.2.延迟绑定的机制
设 C 是我们向其发送消息“om()”
的对象 o 的真实类
如果 C 类代码包含 m() 方法的定义（或重新定义），

则将执行该方法
否则，
继续在 C 的父类中搜索方法 m()，
然后在该父类的父类中，
依此类推，
直到找到
方法 m() 的定义，
然后执行该方法
8.2.3.多态的兴趣
多态性最小化代码编写
多态性提升了应用程序的扩展性
您可以创建新的子类，
其实例可以在不触及已编写的程序的情况下被考虑在
内
示例：类
Person { public
void
whoAreYou() {System.out.println( person );}
⋯⋯
}
类学生扩展人
{ public void whoAreYou() {System.out.println( student );}

⋯⋯
}
员工类扩展人
{ public void whoAreYou() {System.out.println( 员工 );}

⋯⋯
}
公共类多态性
{ public static void main(String[] args)

{人p;积分;
System.out.println( 键入 1,2 或 3 );扫描
仪 s = 新扫描仪 (System.in); x = s.nextInt(); //又
一个新对象if (x = =1) p= new Person(); else if (x
= = 2) p = new Student();别的
p = 新员工（）；
p.whoareyou(); // 多态调用 }
68
} 面向对象程序设计课程

ch3 4zh

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ch3 4zh

Uploaded by

Copyright:

Available Formats

Machine Translated by Google

int [] firstArray, secondArray; float thirdArray[ ],变量；

下图是表示访问 tab[i] 的正确方式：

诠释垫 [ ] [ ]; // mat 表示具有两个索引的 int 数组 int[] mat[]; //

[0] [1] [2] [3] [4]

{ public static void main(String[] args)

{ public static void main(String[] arg)

2.2. String类 JAVA在其库（API）

String 类提供字符串常量对象。 ⇔用于处理不可修改的字符串

String msg = 你好！ ;

System.out.println( ch1: +ch1);//JAVA编程

扫描仪 s = 新扫描仪 (System.in); ch3 =

if (str1 == str2) ... // 没有错误

字符串内容的比较： if (str1.equals(str2)) ...

或者再次： str1.compareTo(str2)； CompareTo

equalsIgnoreCase方法与 equals 的作用相同

访问字符串中的一个字符： charAt(index) ⇒ 从指定的字符串中

replace(oldChar, newChar) 方法用于将字符串中的所有 oldChar 字符替换为

int indexOf(char ch)：

int indexOf(String str)：

void setlenght (int newLong)：

StringBuffer append(char c)：

StringBuffer append(String str)：

StringBuffer append(char str[])：

StringBuffer insert(int i, char c)：

StringBuffer insert(int i, String str)：

StringBuffer st = new StringBuffer(); st.append( 课程 );

⇒ StringBuffer 是动态演变的。 ⇒如果其内容的长度增加，

注意： ‑ 类型 B 的已声明对象引用可以引用类型 D 的对象 ‑ 反之则为假

所有类都继承自 JAVA API 的 java.lang 包中定义的 Object 类（即使没有

[访问修饰符] class DerivedClass extends

public void print()

} public void changeAddress (String addr)

public void newLevel(int n) {level =

public String getFirstname()

public String toString()

public void display()

public String toString()

可以在 Base 类和 Derived 类中声明具有相同名称的属性。

为了将属性与基类区分开来， 使用了以下方法之一： 在它前面加上super在它

{ System.out.println( x= +x+ y= +y); }

public void display() { //

} public class THB

casting operator can be used to convert a casting operator可用

public class StudentTest

The inherited member is of public modifier: 继承成员是public modifier:

同一包中的派生类 同一个包中的 另一个包中的派生类 类

如果 C 类代码包含 m() 方法的定义（或重新定义），

{ public void whoAreYou() {System.out.println( student );}

{ public void whoAreYou() {System.out.println( 员工 );}

{ public static void main(String[] args)

You might also like

为了将属性与基类区分开来，使用了以下方法之一：在它前面加上super在它

同一包中的派生类同一个包中的另一个包中的派生类类