第三章java面向对象技术基础(6学时)

格式：ppt
大小：666.00 KB
文档页数：191

下载文档原格式

第3章：面向对象编程基础

3.2 Java的类和对象
(2) 成员变量
成员变量定义的一般形式如下： [修饰字] 类型变量名；其中，修饰字可以空缺，修饰字用于对成员变量限制其访问权限，成员的访问权限有４种：private、protected、public 和友好的（后面详细介绍）。变量的类型可以是任何数据类型，变量的名字是一个标识符。Java 中成员变量的名字可以与类的方法的名字相同。成员变量对类内定义的方法都有效。类的方法也可定义变量，这种变量称为局部变量，局部变量只在定义它的方法中有效。
3.1 面向对象的基本概念
3. 消息（方法调用的信息）
对象之间的交互通过相互发送消息（Message ）实现。当对象Ａ希望对象Ｂ执行Ｂ的一个方法时，用对象Ａ发送消息给对象Ｂ来实现。消息发送时，如果还需要其他参数，消息可带参数一起发送。
3.1 面向对象的基本概念
4. 类（对象的类属/类别）
程序设计中利用抽象，在面向过程阶段，系统按函数和模块进行设计。在面向对象阶段，利用抽象按类设计。类是目前支持抽象的最好工具。
3.1 面向对象的基本概念
2. 对象: (万物皆为对象)
对象有状态（属性）、行为（操作）和名称（对象名）对象的名称用于程序引用对象，对象的成员变量，用于存储对象的状态信息，对象的方法用于描述对象的行为
练习题
【真题练习】参照以下Java代码，以下四个叙述中最确切的是（）
class A{ int x; static int y; void fac(String s){ Syatem. out. println(＂字符串:＂+s); } } A．x、y和s都是成员变量 B．x是实例变量、y是类变量、s是局部变量 C．x和y是实例变量、s是参数 D．x、y和s都是实例变量

第三章JAVA语言基础笔记

Java语言基础本章的主要目标：1、了解java的主类的结构；2、了解java语言中的基本数据类型；3、了解java语言中的常量和变量；4、了解java语言运算符的使用；5、了解java语言数据类型的转换；6、了解java语言中代码注释与编码规范；Java主类结构Java语言是面向对象的程序设计语言，java的基本组成单元就是类，类体又包括属性和方法，而每一个程序都必须包含一个main()方法，含有main()方法的类称之为主类；我们用一个程序来看一下主类的结构:public class First{static String s1=”java”;public static void main(String args[]){String s2=”学习之旅！”;System.out.println(“s1”);System.out.println(“s2”);}}这就是一个简单的java程序，包含了类的结构；需要注意的是，java代码中所有的标点符号，括号都是需要在英文状态下输入；否则在编译的时候将会报错；通常将类的属性称之为类的全局变量（又叫成员变量），将方法中的属性称之为局部变量；全局变量声明在类体中，局部变量声明在方法体中；Java程序中的main()方法必须声明为public staticvoid 。

main()方法是程序开始执行的位置；Java语言严格区分大小写；基本数据类型Java中的基本数据类型有字符和数字之间可以相互转换；在程序执行过程中，其值不能改变的量称为常量，其值能改变的量称之为变量；Java语言规定标识符由任意顺序的字母、下划线、美元符号、和数字组成，并且第一个字符不能使数字字符；Java中允许使用汉字或其他语言作为变量名，但不建议使用；常量名通常使用大写字母，但这并不是必须的，很多java程序员使用大写字母表示常量，常常是为了清楚的表明正在使用常量；由于变量被定义出来后只是暂存在内存中，等到程序执行到某一个点后，该变量会被释放掉，也就是说变量有他的生命周期；在一个方法中，局部变量和成员变量同名时，此时成员变量将被隐藏，即这个成员变量在这个方法中暂时失效；如果从低精度类型向高精度类型转换，则永远不会溢出，并且总是成功的；把高精度类型转换为低精度类型则必然会有信息的丢失；从低精度类型向高精度类型转换，系统自动执行，程序员无需进行任何操作，这种类型的转换又叫隐式转换，从高进度类型向低精度类型转换，则需要强制执行，又叫强制类型转换，又称显示转换；当一个数超过了要转换的类型的最大值，则转会后的数值则会变为最小值，这也可以理解为数据的溢出；代码注释分为单行、多行、和文档注释；编码规范，简言之就是利人利己；。

Java开发技术大全第三章

第3章对象和类在当今的计算机大型应用软件开发领域，面向对象技术正在逐步取代面向过程的程序设计技术。

本章将介绍面向对象的基本知识和Java实现面向对象程序设计的主要工具--类。

如果读者缺乏关于面向对象程序设计的背景，一定要仔细地阅读本章。

如果读者有C++编程经验，也要注意二者之间的区别，毕竟Java在类的具体实现上与C++有较大的差别。

3.1 面向对象的基本概念面向对象（Object Oriented，OO）是当前计算机界关心的重点，它是90年代软件开发方法的主流。

面向对象的概念和应用已超越了程序设计和软件开发，扩展到很广的范围。

例如，数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

谈到面向对象，这方面的文章非常多。

但是，明确地给出"面向对象"的定义却非常少。

最初，"面向对象"是专指在程序设计中采用封装、继承、抽象等设计方法。

可是，这个定义显然不能再适合现在的情况。

面向对象的思想已经涉及到软件开发的各个方面。

例如，面向对象的分析（Object Oriented Analysis，OOA），面向对象的设计（Object Oriented Design，OOD）以及经常说的面向对象的编程（Object Oriented Programming，OOP）。

许多有关面向对象的文章，都只是讲述在面向对象的开发中所需要注意的问题，或所采用的比较好的设计方法。

看这些文章只有真正懂得什么是对象，什么是面向对象，才能最大程度地收获知识。

说明：在本章中，着重讨论OOP，有关OOA和OOD请读者查阅有关软件工程的书籍。

OOP从所处理的数据入手，以数据为中心而不是以服务（功能）为中心来描述系统。

它把编程问题视为一个数据集合，因为数据相对于功能而言，具有更强的稳定性。

OOP同结构化程序设计相比最大的区别就在于：前者首先关心的是所要处理的数据，而后者首先关心的是功能。

chap1Java与面向对象程序设计

2. 面向对象的设计形成OOD模型 • 在OOA模型基础上引入界面管理、任务管理和
数据管理三部分内容。
• 界面管理负责整个系统的人机界面的设计
• 任务管理负责处理并行操作之类的系统资源管理功能的工作
• 数据管理负责设计系统与数据库的接口。 3. 面向对象的实现 • 选择一种合适的编程语言 • 实现各个类 • 集成 • 维护
对象的操作1 对象的操作2
打开
关闭
对象的操作n
对象的状态静态属性（变量）
颜色大小开启
对象的操作3 换台
对象的操作
……
方法一方面把对象内部的变量包裹封装保护起来，一方面与外部交互
• 对象的标志，一般是指对象名，用于区别同一类的各个对象
• 由于对象是类的实例化，因此在程序中通常是先定义类即定义同类对象的公共属性包括变量和方法，然后再用对象名创建类的实例对象
现实世界
计算机世界对象
映射
实体
抽象实例化
抽象概念世界
类
抽象数据向对象技术的核心概念之一。如上图所示，对象就是现实世界中某个具体的物理实体在计算机中的映射和体现。对象拥有各自的静态属性和相关的操作。比如，现实世界中的电视机是一个实体，有品牌、尺寸、颜色、开关、控制器等。
，最终形成一个广泛联系的可理解扩充维护更接近问题本来面目的动态对象模型系统
• 对象：是现实世界的实体或概念在计算机中的抽象表示。用来模拟组成或影响现实世界问题的一个或一组因素。(下一节详细介绍)
• 面向对象程序设计的优点：
1. 对数据的封装提高了程序的可复用和可维护性封 2. 由于封装，保护私有数据
第三阶段面向对象的实现
进行具体的编程、模块连接及测试

《Java_2面向对象程序设计基础》第3章：Java语法基础

Java语法基础 Java语法基础
标识符、关键字、 1.1 标识符、关键字、数据类型和注释变量、 1.2 变量、方法值传递和关键字this 1.3 值传递和关键字this 1.4 表达式和流程控制 1.5 数组
1.1.1 标识符
在Java语言中，标识符是变量、类或方法的名 Java语言中，标识符是变量、语言中例如：称，例如： int idCounter;//idCounter 就是一个整型变量的标识符标识符的组成：标识符的组成：
1.1.3 引用数据类型
java语言中除8种基本数据类型外，其他的数据类型统称为 ava语言中除8种基本数据类型外， ava语言中除引用类型（ type），具体包括：），具体包括接口、数组、引用类型（reference type），具体包括：类、接口、数组、枚举和注解类型。枚举和注解类型。引用类型数据以对象的形式存在。引用类型数据以对象的形式存在。引用类型变量的值是某个对象的句柄，而不是对象本身。引用类型变量的值是某个对象的句柄，而不是对象本身。声明引用类型变量时，系统只为该变量分配引用空间，声明引用类型变量时，系统只为该变量分配引用空间，并未创建一个具体的对象。创建一个具体的对象。
1.1.3 基本Java数据类型基本Java数据类型
字符—— ——char (3) 字符——char
char型数据用来表示通常意义上的“字符” char型数据用来表示通常意义上的“字符”，型数据用来表示通常意义上的 java语言采用16位Unicode编码保存语言采用16 编码保存。 java语言采用16位Unicode编码保存。字符常量的三种表示方法：字符常量的三种表示方法：使用单引号括起来的单个字符，例如：使用单引号括起来的单个字符，例如： c='A'； char c='A'；十六进制编码形式表示，例如：十六进制编码形式表示，例如： c1='\ char c1='\u0061'; 使用转义字符' 使用转义字符'\’来将其后的字符转变为其他含例如：义，例如： c2=‘ //代表换行符 char c2=‘\n’；//代表换行符

java语言程序设计(一)第三章补充

专接本辅导java第三章《面向对象编程基础》补充0.类变量与实例变量区别（类方法与实例方法的区别见习题解答第12题改错）java类的成员变量有两种：一种是被static关键字修饰的变量，叫类变量或者静态变量；另一种没有static修饰，为实例变量。

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。

静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，只在类被第一次装置时初始化一次staticVar变量和sum变量，并且每创建一个实例对象，就会执行一次构造函数；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

public class类变量与实例变量{public static int staticVar = 0;//类变量初始化，只会在类装载时进行一次！！public int instanceVar = 0;//实例变量初始化public static int sum=1;public类变量与实例变量()//构造方法{staticVar++;instanceVar++;sum=sum+5;System.out.println("staticVar = "+staticVar+",instanceVar="+instanceVar);System.out.println("sum = "+sum);}public static void main(String []args){类变量与实例变量对象1=new类变量与实例变量();类变量与实例变量对象2=new类变量与实例变量();类变量与实例变量对象3=new类变量与实例变量();}}运行结果：staticVar = 1,instanceVar=1sum = 6staticVar = 2,instanceVar=1sum = 11staticVar = 3,instanceVar=1sum = 16再如下面的程序，涉及static块：class Value{static int c=0;static int d;Value(){c=15;d=65;}Value(int i){c=i;d=c-1;}static void inc(){c++;}}public class Count {Value v0=new Value();//调用无参构造函数建立Value类非静态对象v0，类Count和类Value是has-a关系Value v=new Value(10);//调用有参构造函数建立Value类非静态对象vstatic Value v1,v2;//声明Value类的static对象v1,v2//static Value v1=new Value(),v2=new Value();//声明v1、v2并引用新建立的Value类对象static{//★声明static块，其初始化工作会先于任何其它非static块及非static变量而不管其在源程序书写中出现的先后次序！System.out.println("static块中println语句执行结果:"+"\n"+"v0和v是非静态内部类对象，v1和v2是静态内部类对象（请与教材P58例3.18对比），只有声明没有具体指向某对象时：v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);v1=new Value(30);//对象v1引用新建立的Value类对象System.out.println("static块中执行完“v1=new Value(30)之后：”v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);v2=new Value(15);//对象v2引用新建立的Value类对象System.out.println("static块中执行完“v2=new Value(15)之后：”v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);System.out.println("特别说明：因此时还没有建立Count类对象（Count 类和Value类是has-a关系，前者是外部类，后者是内部类）故非静态对象v0和v无法引用！"+"\n");}public static void main(String[] args) {Count ct1=new Count();//建立Count类（外部类）对象Count ct2=new Count();System.out.print("在main方法中，现在建立Count类（外部类）对象，");System.out.println("ct1的在ct2之前创建！分别指向两个Count类对象，Count类和Value类是has-a关系！"+"\n"+"以下是main方法体中println语句执行结果：");System.out.println("v0是无参构造内部类非静态对象，ct1.v0.c="+ct1.v0.c+" ct1.v0.d="+ct1.v0.d+" ct2.v0.c="+ct2.v0.c+"ct2.v0.d="+ct2.v0.d);// 非静态内部类对象只能通过外部类对象名访问System.out.println("v是有参构造内部类非静态对象，ct1.v.c="+ct1.v.c+" ct1.v.d="+ct1.v.d+" ct2.v.c="+ct2.v.c+" ct2.v.d="+ct2.v.d);// 非静态内部类对象只能通过外部类对象名访问System.out.println("v1是有参构造内部类静态对象，Count.v1.c="+Count.v1.c+" count.v1.d="+Count.v1.d);//静态内部类对象可以通过外部类名访问System.out.println("v2是有参构造内部类静态对象，Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);Value.inc();//通过类名调用类方法System.out.println("调用类方法inc()之后Count.v1.c="+Count.v1.c+" Count.v1.d="+Count.v1.d);//引用类变量既可以通过类名也可以通过对象名System.out.println("调用类方法inc()之后Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);Count.v2.inc();//通过类名调用类方法，这种写法不妥！System.out.println("调用类方法v1.inc()之后Count.v1.c="+Count.v1.c+" Count.v1.d="+Count.v1.d);//引用类变量既可以通过类名也可以通过对象名System.out.println("调用类方法v1.inc()之后Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);ct1.v0.c++;//this.v0.c++;//错误，★不能在静态上下文中使用this关键字:！因为Value是Count的内部类，只能使用其外部类的对象ct2.v0.c++;System.out.println("顺序执行语句：ct1.v0.c++;ct2.v0.c++;后，ct1.v0.c="+ct1.v0.c+" ct2.v0.c="+ct2.v0.c);// 非静态内部类对象只能通过外部类对象名访问}}上面这个程序的行动结果如下：static块中println语句执行结果:v0和v是非静态内部类对象，v1和v2是静态内部类对象（请与教材P58例3.18对比），只有声明没有具体指向某对象时：v1.c=0 v2.c=0 v1.d=0 v2.d=0static块中执行完“v1=new Value(30)之后：”v1.c=30 v2.c=30 v1.d=29 v2.d=29static块中执行完“v2=new Value(15)之后：”v1.c=15 v2.c=15 v1.d=14 v2.d=14特别说明：因此时还没有建立Count类对象（Count类和Value类是has-a关系，前者是外部类，后者是内部类）故非静态对象v0和v无法引用！在main方法中，现在建立Count类（外部类）对象，ct1的在ct2之前创建！分别指向两个Count类对象，Count类和Value类是has-a关系！以下是main方法体中println语句执行结果：v0是无参构造内部类非静态对象，ct1.v0.c=10 ct1.v0.d=9 ct2.v0.c=10 ct2.v0.d=9v是有参构造内部类非静态对象，ct1.v.c=10 ct1.v.d=9 ct2.v.c=10 ct2.v.d=9 v1是有参构造内部类静态对象， Count.v1.c=10 count.v1.d=9v2是有参构造内部类静态对象， Count.v2.c=10 count.v2.d=9调用类方法inc()之后 Count.v1.c=11 Count.v1.d=9调用类方法inc()之后 Count.v2.c=11 count.v2.d=9调用类方法v1.inc()之后 Count.v1.c=12 Count.v1.d=9调用类方法v1.inc()之后 Count.v2.c=12 count.v2.d=9顺序执行语句：ct1.v0.c++;ct2.v0.c++;后，ct1.v0.c=14 ct2.v0.c=14以上运行结果中，有五点值得注意：一是static变量和static块是在类第一次装载时被初始化一次，并供类的所有对象共享，故static变量和static块中内容最先被初始化（早于main方法）。

JAVA第三章课后习题解答

抽象类不具备实际功能抽象类不具备实际功能抽象类不具备实际功能是专门设计用是专门设计用是专门设计用来让子类继承的类来让子类继承的类来让子类继承的类把这些具有共同特征的方法抽象出来把这些具有共同特征的方法抽象出来把这些具有共同特征的方法抽象出来由子类负责这些抽象方法的实现由子类负责这些抽象方法的实现由子类负责这些抽象方法的实现细节而父类仅提供此方法的名称和声明没有方法的主体细节而父类仅提供此方法的名称和声明没有方法的主体细节而父类仅提供此方法的名称和声明没有方法的主体该类
System.out.println(s); return s; } }
public class TestStudent { public static void main(String args[]) { student stu = new student("0401398", "杨小明", "男",20); stu.printInfo();
【13】什么是接口？为什么要定义接口？接口和类有什么异同？ [解答]：接口是用来调节各类之间的相互关系的一种结构，接口是抽象类的一种，只包含常量和方法的定义，而没有变量和具体方法的实现，且其方法都是抽象方法。接口定义的格式如下：
[public] interface 接口名 [extends 父接口名列表]{ … //接口体 } extends 子句有类声明的 extends 子句基本相同，不同的是一个接口可有多个父接口，用逗号隔开，而一个类只能有一个父类。Java 中的类只能实现单重继承，这虽然可以简化编程，但毕竟没有完全实现面向对象的功能。定义接口的主要作用，就是帮助 Java 实现类间多重继承的结构。而且接口还有以下好处：
4
● 接口可以被多个类所实现，这些类可以不相关，从而具有相同的行为。 ● 通过接口可以了解对象的行为，而无需了解对象所对应的类的结构。

郎波《Java语言程序设计(第4版)》教学进度表-48学时

习题5：
6
12
2
第5章Java高级特征：
集合类；
枚举类型；
包装类与自动装箱和拆箱；
注解Annotation；
var局部变量类型推断
实训4：
练习4-3
习题5：
7
13
2
第6章异常处理：
异常的概念；
异常处理方法；
自定义异常类
实训5：
练习5-1
练习5-2
习题6：1-5
14
2
第7章输入/输出：
输入/输出流的概念；
《Java语言程序设计（第4版）》教学进度表（48学时）
课次
学时
计划教学内容
教学内容
实验
习题
1
2
第一章绪论：
面向对象程序设计概述；
Java发展历史与技术体系；
Java的特征
习题1:
1-2
2
2
第一章绪论：
Java语法机制；
Java运行系统；
Java应用;
Java程序示例
实训1：
练习1-1，
练习1-2
习题1:
19
2
第9章Applet编程：
Applet基本概念；
Applet的编写；
Applet中的图形化用户界面GUI
习题9：
1-7
20
2
第10章线程：
线程的概念；
线程的两种构造方法；
线程调度
实训8：
练习8-1
习题10：
1-4，8
21
2
第10章线程：
线程控制；
线程同步
习题10：
6，7
22
2
第10章线程：
线程间的交互；

JAVA面向对象程序设计教学大纲.doc

《JAVA面向对象程序设计》课程教学大纲Oriented object Programming in JAVA编号：08065121适用专业：计算机科学与技术、网络工程学时数：32 学分数：2执笔者：田小玲编写日期：2009年11月一、课程的性质和目的本课程是为计算机科学与技术以及网络工程专业本科生开设的专业选修课，是一门面向对象的编程语言，通过本课程的学习，培养和提高学生面向对象程序设计的能力和Java语言在web开发中的应用能力。

二、课程教学内容第一章面向对象软件开发概述（2学时）1.内容面向对象问题求解的提出、面向对象问题求解的概述、对象、类与实体、对象的属性与相互关系、面向对象的软件开发过程、面向对象程序设计方法的优点、开发环境设置及开发工具简介。

2.要求（1）了解：面向对象软件开发概述，面向对象的软件开发过程及面向对象程序设计方法的优点。

（2）掌握：对象的属性与相互关系，对象、类与实体的基本概念。

（3）熟练掌握：开发环境设置及开发工具简介（补充）。

3.重点对象、类与实体的基本概念。

4滩点面向对象程序设计方法的理解。

第二章Java概述（2学时）1.内容Java语言的特点、Java虚拟机及垃圾回收机制、JDK目录结构、Java的API结构及Java 程序结构、第一个Java Application程序、第一个Java Applet程序、图形界面的输入输出、字符界面的输入输出。

2.要求（1）了解：Java语言的发展历史及特点，Java Application程序及Java Applet程序，图形界面的输入输出，字符界面的输入输出。

（2）掌握：Java语言实现机制（补充）,Java体系结构（补充）。

（3）熟练掌握：Java Application程序的结构。

3.重点Java Application 程序的结构。

4滩点Java语言实现机制。

第三章Java语言基础（2学时）1.内容数据类型、变量与常量、表达式、流程控制语句。

Java面向对象

两个类声明的例子
class Car { … }
class 工厂 { … }
类体的构成：
① 成员变量：通过变量声明定义的变量，用来刻画类创建的对象的属性。
② 成员方法
构造方法：类创建对象时使用，用来给出类所创建的对象的初始状态。
普通方法：供对象调用，体现对象具有的某种功能。
例：一个梯形类的定义
[public | protected | private ] [static] [final | abstract] [native] [synchronized]
返回类型可以是任意的Java数据类型，当一个方法不需要返回值时，返回类型为void。
参数的类型可以是简单数据类型，也可以是引用数据类型（数组、类或接口），参数传递方式是值传递。
轿车
计程车
巴士
多态性——
不同的类对象收到同一个消息可以产生完全不同的响应效果，这种现象叫做多态。利用多态机制，用户可以发送一个通用的消息，而实现的细节由接收对象自行决定，这样，同一个消息可能会导致调用不同的方法。
面向对象程序设计
面向对象程序设计(Object-Oriented Programming,OOP)方法是指用面向对象的方法指导程序设计的整个过程，所谓面向对象是指以对象为中心，分析、设计及构造应用程序的机制。
在程序设计中，软件对象的概念由真实世界对象而来。
状态==变量（variables）或称数据字段（data field）
行为==方法（methods）对象实现了状态和行为的结合，使状态和
行为封装于对象的统一体中。
方法（行为）
method 1 data field 1 data field n

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

分为实例方法和类方法
二、方法调用
给对象发消息意味着调用对象的某个方法：
从对象中取得信息修改对象的状态或进行某种操作进行计算及取得结果等
参数传递：
值传递：参数类型为基本数据类型时引用传递：参数类型为引用类型或数组时
三、实例方法声明时前面不加static修饰符; 表示特定对象的行为; 使用时需要发送给一个类实例。 <对象名>.<方法名>([参数列表])
例3-1:声明钟表类
public class Clock{ // 变量成员 int hour, minute, second; // 方法成员 public void setTime(int newH, int newM, int newS){ hour=newH; minute=newM; second=newS; } public void showTime(){ System.out.println(hour+":"+minute+":"+second); } }
测试结果:1 2
2
2
3.2.4 方法成员方法成员:定义类的行为，可以没有，也可以有多个。一、声明格式: [public | protected | private] [static][final][abstract][native][synchronized] 返回类型方法名([参数列表]) [throws exceptionList] { 方法体 }
其作用是：
在内存中为此对象分配内存空间; 返回对象的引用(reference ，相当于对象的存储地址).
3.2.3 数据成员
数据成员：表示Java类的状态
声明数据成员必须给出变量名及其所属的类型，同时还可以指定其他特性；
在一个类中成员变量名是唯一的；
数据成员的类型可以是Java中任意的数据类型(简单类型、类、接口lass CircumferenceTester { public static void main(String args[]) { Circle c1 = new Circle(); c1.radius = 50; Circle c2 = new Circle(); c2.radius = 10; double circum1 = c1.circumference(); double circum2 = c2.circumference(); System.out.println("Circle 1 has circumference " + circum1); System.out.println("Circle 2 has circumference " + circum2); } }
类将属性及行为相同或相似的对象归为一类；
类可以看成是对象的抽象，代表了此类对象所具有的共有属性和行为；
在面向对象的程序设计中，每一个对象都属于某个特定的类。
面向对象的三大特点：封装、继承、多态一、封装是一种信息隐蔽技术；利用抽象数据类型将数据和基于数据的操作封装在一起；用户只能看到对象的封装界面信息，对象内部细节对用户是隐蔽的；封装的目的在于将对象的使用者和设计者分开，使用者不必知道行为实现的细节，只需使用设计者提供的消息来访问对象。
public class Circle { int radius; } public class ShapeTest { public static void main(String args[]) { Circle x; x = new Circle(); System.out.println(x); System.out.println("radius = " + x.radius); } }
单继承：任何一个派生类都只有单一的直接父类；类层次结构为树状结构。多继承：一个类可以有一个以上的直接父类；类层次结构为网状结构，设计及实现比较复杂。 Java语言仅支持单继承。
三、多态不同类的对象可以响应同名的消息(方法) ，具体的实现方法却不同；
主要通过子类对父类方法的覆盖来实现；
例3-4:在Circle类中声明计算周长的方法。 public class Circle { static double PI = 3.14159265; int radius; public double circumference() { return 2 * PI * radius; } }
声明格式: [public | protected | private] [static][final][transient][volatile] 变量数据类型变量名1[=变量初值], 变量名2[=变量初值], … ; 格式说明: public、protected、private 为访问控制符 static指明这是一个静态成员变量 final指明变量的值不能被修改 transient指明变量是临时状态 volatile指明变量是一个共享变量
结构化程序设计
通常由若干个程序模块组成，每个程序模块都可以是子程序或函数；
数据和功能分离，代码难于维护和复用。
面向对象程序设计
基本组成单位是类；对象之间通过发送消息进行通信，互相协作完成相应功能；程序在运行时由类生成对象，对象是面向对象程序的核心。
对象现实世界中，万物皆对象，都具有各自的属性，对外界都呈现各自的行为。程序中，一切都是对象，都具有标识 (identity), 属性和行为(方法)：通过一个或多个变量来保存其状态；通过方法(method) 实现他的行为。
分为实例变量和类变量实例变量没有static修饰的变量，用来存储所有实例都需要的属性信息，不同实例的属性值可能会不同。
可通过下面的表达式访问实例变量的值： <实例名>.<实例变量名>
例3-2:声明一个表示圆的类，保存在文件 Circle.java 中。然后编写测试类，保存在文件 ShapeTest.java中，并与Circle.java放在相同的目录下。
修改ShapeTest对类变量进行测试 public class ShapeTest{ public static void main(String args[]) { Circle x = new Circle(); System.out.println(x.PI); System.out.println(Circle.PI); Circle.PI = 3.14; System.out.println(x.PI); System.out.println(Circle.PI); } }
JAVA语言程序设计
第三章 java面向对象技术基础
目录
3.1 面向对象的基本概念 3.2 类与对象 3.3 包package 3.4 类及其成员的访问权限 3.5 final、this及其它 3.6 对象初始化和回收 3.7java异常处理 3.8 应用举例 (作业)
6学时
3.1 面向对象的基本概念
关键字 class 表明其后声明的是一个类。 extends 声明的类是从某一父类派生而来，父类的名字写在extends之后 implements 声明的类要实现某些接口，接口的名字写在implements之后
修饰符（可以有多个，用来限定类的使用方式） public 表明此类为公有类 abstract 指明此类为抽象类 final 指明此类为终结类类声明体数据成员声明及初始化，可以有多个方法成员声明及方法体，可以有多个
测试结果: 3.14159265 3.14159265 3.14 3.14
例3-3:声明一个Point类(Point.java)，有两个私有变量保存点坐标，一个类变量保存已有点的个数。 public class Point { private int x; private int y; public static int pointCount=0; public Point(int x, int y) { this.x = x; this.y = y; pointCount++; } }
3.2.2 对象的声明与引用对象的声明格式:
类名变量名;
例如Clock是已经声明的类名，声明的变量 aclock将用于存储该类对象的引用： Clock aclock;
声明一个引用变量时并没有对象生成。
对象的创建格式： new <类名>(); 例如： aclock=new Clock();
测试类Point
public class test{ public static void main(String[] args){ Point p1 = new Point(1,1); System.out.println(p1.pointCount); Point p2 = new Point(2,2); System.out.println(p1.pointCount); System.out.println(p2.pointCount); System.out.println(Point.pointCount); } }
适用情况：
类中所有对象都相同的属性；经常需要共享的数据；系统中用到的一些常量值。
引用格式
<类名 | 实例名>.<类变量名>
对于一个圆类的所有对象，计算圆的面积时，都需用到π的值，可在Circle类的声明中增加一个类属性PI。
public class Circle { static double PI = 3.14159265; int radius; } 当我们生成Circle类的实例时，在每一个实例中并没有存储PI的值，PI的值存储在类中。