第一篇：完成Java面向对象程序设计实验课的心得体会
Java面向对象程序设计实验课的心得体会
经过这几周对Java面向对象程序设计的学习，让我更加了解到Java学习的重要性。
在实验课上，我们完成多个实验，在这个阶段的学习中，我从认识到熟悉，而后到能够自主运用。通过对Java的了解，我发现它确实有很多方便之处，它集抽象性、封装性、继承性和多态性于一体，实现了代码重用和代码扩充，提高了软件开发的效率。对于我们这个专业来说学好Java语言是很重要的，所以在实验的过程中我都尽力理解java编程思想、掌握基本技巧，尽量学到最多的知识。
学习程序设计的基本目的就是培养描述实际问题的程序化解决方案的关键技能，Java面向对象程序设计是一门实践性比较强的课程，在实际中，我们必须把理论和实践结合起来。在实验中，我们理解理论课上的知识，然后运用到实际的操作中，我们必须在现有的理论的基础上，进行实践。多次实验后，也让我看到了现在学习的一个很大弱点：只听不练，永远不会熟练运用；空记技巧，忽略思想，会在多变的习题中十分无奈。
Java思想：Java是一门面向对向语言，他定义一切都是对象
面向对象，就是面对现实；
现实中的一切都是对象，他们有分类，就产生了“类”；
他们有不同，类和类之间的不同，使用类来区分；
同一个类中不同的对象的区别，使用成员区分。所以，面向对象的内部逻辑是分类。
面向对象编程思想就象数学上的一些概念，如：空间、群、环、域等
原始的编程思想就象古典数学，人们只在一个集合上探讨问题，没有系统的方法（即运算）定义，于是仁者见仁、智者见智，这样在一定程度上造成了理论的一种混乱局面，不利于科学的发展。于是近代数学向公理化发展，这是什么意思呢？就是说，人们除了在限定论域（即上面的集合，面向对象也有此概念）外，还在此论域上加进了一套通用的、公认的运算（方法）；集合加上集合上定义的运算就构成了数学上的空间、群等，在计算机领域里，就变成为“类”。这种集合上定义了操作的东西利用起来就方便多了，这使得人们讨论问题时都在给定集合的运算能力上下工夫，即有通用性可事半功倍。
面向对象的编程思想就要想近世代数的分析思想，首先要确定“论域”，即工程所涉及到的所有的“对象”，然后要分类处理，把隶属同一类别的对象集合在一起（做成一个集合），定义他们之间的运算性质及可以进行的操作，这样就构建了一个类，当然以后用到这个类的对象时都要通过已经定义了的操作来完成各项功能，这就是常要求的类的“类的成员变量要通过共有函数来操作”。
我想真正的面向对象编程思想不应该是编程思想，应该是面向对象的分析方法才对！
我的理解：
1、将分析过程为抽象的过程：简言之：分成多个小问题（组成部分），直到无法再细；
2、对每个对象（小问题）进行分析，抽象，提取处共同的内容（数据成员和操作方法），3、有相似的对象的，构造基类；再有基类派生出各个确定的对象（小问题）；
4、解决问题的过程就是操作这些对象的过程。
我的理解：
与实际生活联系起来。
将要处理的„问题‟抽象成一个或多个„事件‟
找一个地方使用我的智慧
1。了解系统的功能。列举出它的对外接口，即对于使用者来说它有什么功能。把这整个系统作为一个对象。
2。环境。系统不是运行在真空中的，操作系统等外部环境都可能会影响它。所以把环境也作为一个大的对象。
3。内部。在系统的内部，一般都比较复杂，一般的做法是规定一个粒度，枚举出该粒度上所有的物体。比如说人体，如果在器官的粒度上，就有心，肝，肺。而小于该粒度的物体（或称对象），比如血细胞，就忽略，作为其它物体（或称子系统的内部对象）。
4。子系统。不断缩小粒度，沿用步骤1~3，直到不能再抽象为止。
5。无形的物体。一个完整的互连的系统需要许多无形的物体，比如消息等了，一般这样的对象比较难发现。当你发现各个子系统无法正确合作或理顺关系时，试着加入一些辅助对象。一切都是为了让人明白，有能让机器理解的思想
我想分析和抽象能力的高低是个关键，首先要从问题域分析和抽象出准确的对象模型，再根据这些模型进行处理，当然在过程种少不了楼上前辈们说的一些思想和细节，但是别忘了，我们的目的是解决问题，不要为了面向对象而面向对象！
我想分析和抽象的能力对这个问题是个关键。首先要在问题域仔细分析、抽象得到相关的对象模型，然后才是相应的设计。可是面向对象只是我们解决问题一种思想，切不可忘了问题本身，弄成为了面向对象而面向对象了！当然过程种少不了楼上一些前辈说的思想和细节了。
耕具我多年的实践：面向对象包括两个思想：
从大往小想，从小往大做
从难往易想，从易往难做
同意一下观点-----能深入浅出，真高手也！
真正的面向对象编程思想就是忘掉一切关于计算机的东西，从问题领域考虑问题, :-)把问题从大到小都抽象成对象（指针只是对象的使用形式），在设计和编写程序的时候把你设计的对象合理的编排组合就是面向对象编程了。
面向对象，就是面对现实；
现实中的一切都是对象，他们有分类，就产生了“类”；
他们有不同，类和类之间的不同，使用类来区分； 同一个类中不同的对象的区别，使用成员区分。
所以，面向对象的内部逻辑是分类。
对象：
对象是人们要进行研究的任何事物，从简单的一个小分子到复杂的汽车飞机都可以看做对象，只是有时对象要根据人们研究问题的需要来确定，对象不一定是具体的，有时也可以表示抽象的规则或计划。
类：
类在java中是具有相同或相似性质的对象的抽象体现形式。也就是说，类的实例化就是创建对象的过程类的实例就是对象。
第二篇：java面向对象程序设计教案
武汉大学珞珈学院 系/教研室 Java 面 向 对 象 程 序 设 计 课 教 案
主讲教师：熊春秀 编写时间：2011-4-30
第一章：概述
第 1、2 节：面向对象的基本概念、面向对象程序设计概述 授课时间：2011-2-
22、23
计划学时数：1 教学任务与目的：让学生理解面向对象的基本概念 教学重点：掌握面向对象的基本概念 教学难点：理解面向对象程序设计的方法 教学方法：多媒体+板书 参考书目：《面向对象程序设计导论》，[美]C.Thomas wu著，电子工业出版社 专业词汇：Java虚拟机、Applet程序 备注
第二章：Java特点及运行环境
第 1、2、3 节：Java语言特点、Java应用程序及运行环境、Java Applet程序及运行环境 授课时间：2011-2-
22、23
计划学时数：3 教学任务与目的：让学生学会JDK的下载、安装与环境配置。教学重点：掌握编译和执行Java程序的基本步骤
教学难点：理解Java程序的入口并能够通过命令行传递参数 教学方法：多媒体+板书 参考书目：《面向对象程序设计导论》，[美]C.Thomas wu著，电子工业出版社 专业词汇：JDK、lib、bin 备注 第三章：Java语言基础
第 1、2 节：Java程序的构成、数据类型、表达式以及流程控制语句 授课时间：2011-3-
1、2
计划学时数：3 教学任务与目的：让学生学会Java基本的数据类型和表示方法、数值类型的运算、逻辑运算和比较、条件执行语句（包括三种条件语句和switch语句）、循环控制语句（包括for、while、do while循环及相应的辅助语句）、字符串类String和BufferString以及数组的声明及使用。
教学重点：掌握Java基本的数据类型和表示方法
教学难点：理解Java程序的循环控制语句（包括for、while、do while循环及相应的辅助语句）
教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社 专业词汇：变量、数据类型、循环控制语句 备注 第三章：Java语言基础 第 3 节：Java与C比较
授课时间：2011-3-
8、9
计划学时数：3 教学任务与目的：让学生在C语言的基本上进一步学习Java语言。教学重点：掌握Java语言与C语言的区别与联系。教学难点：理解Java语言在C语言上的改进。教学方法：多媒体+板书 参考书目：《Java2参考大全（第四版）》，[美]Herbert Schildt著，张玉清、吴浦峰、尚勇等译，清华大学出版社。专业词汇：Java、C 备注 第四章：抽象、封装与类
第 1 节：抽象、封装与Java类的概念
授课时间：2011-3-
15、16
计划学时数：3 教学任务与目的：让学生学会面向对象的基本特征、掌握如何定义一个类以及如何生成对象、深入掌握方法的定义及技巧、深入掌握类的访问权限与封装机制、深入掌握包的定义与包的使用方法。
教学重点：掌握类的定义与对象的生成。教学难点：理解类的抽象与封装机制。教学方法：多媒体+板书 参考书目：《Java2 实用教程》，耿祥义、张跃平编著，清华大学出版社。专业词汇：抽象、封装、类 备注 第四章：抽象、封装与类 第 2 节：系统定义的类
授课时间：2011-3-
22、23
计划学时数：3 教学任务与目的：让学生学会使用系统定义的类，并掌握与用户自定义类的区别。教学重点：掌握如何定义所需要的类。
教学难点：熟悉Java平台定义了哪些经常要用到、而且满足我们需要的类。教学方法：多媒体+板书 参考书目：《Java2 实用教程》，耿祥义、张跃平编著，清华大学出版社。专业词汇：系统定义的类、用户自定义类 备注 第四章：抽象、封装与类
第 3 节：类、域和方法的修饰符
授课时间：2011-3-
29、30
计划学时数：3 教学任务与目的：让学生学会类的声明。
教学重点：掌握如何定义类的修饰和方法的修饰符。教学难点：熟悉类的变量的定义与使用方法。教学方法：多媒体+板书 参考书目：《Java2 实用教程》，耿祥义、张跃平编著，清华大学出版社。专业词汇：成员变量、类变量、成员方法、类方法 备注 第五章：继承与多态
第 1、2 节：Java的继承与派生、域的继承与隐藏 授课时间：2011-4-
5、6
计划学时数：3 教学任务与目的：让学生全面掌握面向对象的基本特征、掌握如何使用继承性来到达软件的重用、深入掌握继承过程中域的隐藏和方法的覆盖技巧。教学重点：掌握如何使用继承性来到达软件的重用。教学难点：熟悉继承过程中域的隐藏和方法的覆盖技巧。教学方法：多媒体+板书 参考书目：《Java2 实用教程》，耿祥义、张跃平编著，清华大学出版社。专业词汇：继承派生、域、隐藏 备注 第五章：继承与多态
第 3、4 节：方法的继承、重载与覆盖、this与super、构造函数的继承与重载 授课时间：2011-4-
12、13
计划学时数：3 教学任务与目的：让学生通过继承可以更有效地组织程序结构，明确类之间的关系，并充分利用已有的类来创建新类，通过继承可以实现代码的重用，以完成更复杂的设计、开发。教学重点：掌握类的重载与覆盖的区别与联系。教学难点：熟悉类的重载与覆盖使用方法。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：继承、重载、覆盖、this、super 备注 第五章：继承与多态
第 5、6 节：多态性的实现、接口声明与实现 授课时间：2011-4-
19、20
计划学时数：3 教学任务与目的：让学生深入掌握抽象类和抽象方法的定义，掌握多态通过统一多个相关类的对外接口，在运行时根据不同的情况执行不同的操作，提高类的抽象度和灵活性，深入掌握接口的定义和使用技巧。
教学重点：熟悉多态性实现的两种方式以及接口的实现。教学难点：熟悉多态性与接口的实现方法。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：多态性、接口 备注 第六章：工具类与算法
第 1、2 节：语言基础类库、Applet类与小程序的基本原理 授课时间：2011-4-
26、27
计划学时数：3 教学任务与目的：深入了解Applet生命周期的主要方法和特点、熟练掌握Applet程序的编写方法、深入了解Applet的安全机制及其合理运用。教学重点：熟练掌握Applet程序的编写方法。
教学难点：深入了解Applet的安全机制及其合理运用。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：Applet、生命周期 备注 第六章：工具类与算法
第 3、4 节：数组、字符串、常用算法
授课时间：2011-5-
3、4
计划学时数：3 教学任务与目的：让学生学会字符串类String和BufferString、数组的声明及使用。教学重点：熟练掌握字符串与数组的使用方法。教学难点：深入了解数组的使用方法。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：数组、字符串 备注 第七章：用户图形界面的设计
第 1、2 节：用户自定义成分、事件驱动设计 授课时间：2011-5-
10、11
计划学时数：3 教学任务与目的：让学生学会使用面向对象的程序设计方法构建图形用户界面、深入了解抽象窗口工具包（AWT）、掌握事件处理基本原理和方法。教学重点：熟练掌握图形用户界面的开发方法。教学难点：深入了解图形界面的各种事件。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：AWT、GUI 备注 第七章：用户图形界面的设计
第 3、4 节：GUI对象，包括：按钮、文本框、鼠标、键盘等事件的处理、布局设计 授课时间：2011-5-
17、18
计划学时数：3 教学任务与目的：让学生深入了解GUI构件及掌握布局控制方法、熟练掌握菜单和对话框、掌握简单绘图方法。
教学重点：熟练使用Java语言提供的布局管理器来管理组件在容器中的布局。教学难点：深入了解组件在程序中安排中位置和大小使用方法。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：布局管理器、容器 备注 第八章：Java高级编程
第 1、2、3节：异常处理、多线程机制、Java程序对网上资源的访问 授课时间：2011-5-
24、25
计划学时数：3 教学任务与目的：让学生深入理解多线程的基本概念、熟练掌握创建线程的两种基本方法、熟练处理线程的同步问题和死锁问题、深入理解异常的基本概念、熟悉和掌握Java平台定义异常类、熟练掌握创建自定义异常类的方法。教学重点：熟练掌握创建线程的两种基本方法。教学难点：深入了解线程的同步问题和死锁问题。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：同步、死锁、多线程、异常
第三篇：Java面向对象程序设计教学大纲
Java面向对象程序设计课程教学大纲
Object-Oriented Programming with Java Syllabus
课程名称 课程类别 建设单位/教研室 前后课程 适用专业、层次 Java面向对象程序设课程英文名Object-Oriented Programming with Java 计 称 专业必修课 学分/学时 4.0/42+42 计算机系/软件工程教研室 考核方式 考试 C语言程序设计
软件工程、计算机科学与技术、网络工程
Upon completion of this course, students should master the basic knowledge of Java language, understand and grasp the basic object-oriented programming design ideas and skillfully use Java language to write, compile and debug programs.These would lay a good foundation for students on independently finish the work of program development with Java in the future.教学目的
The emphasis: 1.The origin of Java, Why should we learn Java language, Java cross-platform principle analysis(JVM)and Java Environment variable configuration.2.Data and Expressions: including Character Strings, Variables and Assignment, Primitive Data Types, Expressions, Data Conversion, Interactive Programs.3.Oriented object programming ideas: including Class, Object, Variables, Methods, Encapsulation, Inheritance, Polymorphism, Interface and so on.4.Java statements: including conditionals and loops statements.5.Arrays: Declaring and using one-dimensional arrays and two-dimensional arrays.6.Exceptions: including exception handling, uncaught exceptions, and try-catch statement and so on.7.GUI: including event handling and graphics user interface.The difficulty：
Object-oriented concept and idea, establishing application model and algorithm of description, the algorithm optimization of program and so on.教材和主要参考资料： Text and references Text ：
John Lewis “Java程序设计教程(第六版)英文版” 电子工业出版社 ISBN-978-7-121-08808-7 References：
1.《Java编程思想(英文版 第3版)》，（美）Bruce Eckel编，机械工业出版社出版社； 2.Java程序设计基础》，（美）Gary J.Bronson编, 赵德奎 林仕平译，北京大学出版社。
3.Cay S.Horstmann, Gary Cornell.Java 2核心技术 卷I:基础知识.机械工业出版社, 2001.4.Cay S.Horstmann, Gary Cornell.Java 2核心技术 卷II:高级特性.机械工业出版社, 2001.教学内容 学时 基本要求
按章、节具体列出
教学内容 Topic 具体列出教学的基本要求，如了解、理解、掌握及应用等。
By the end of chapter ,students should understand Chapter 1 Introduction
Chapter 2 Data and ExpressionsChapter 3 Using Classes and Objects Chapter 4 Writing Classes 3+3 To be able to have a fundamental understanding of software role in a computer system. To know components of a computer To understand how those components interact To grasp how computers store and manipulate information To know how computers are connected into networks to share information. To profile programming and programming languages To profile an introduction to Java To grasp object-oriented concepts 3+6 Explore some of the basic types of data used in a Java program and the use of expressions to perform calculations. To understand character strings, concatenation, and escape sequences. To grasp the declaration and use of variables. To be familiar with Java primitive data types. To understand expressions and operator precedence. To grasp the syntax and processing of expressions. To understand the types of data conversions and the mechanisms for
accomplishing them. To know how to create interactive programs. To understand the basic graphic concepts and the techniques for drawing
shapes. To know the concept of a Java applet.4+4 Use the predefined classes in the Java class library that are provided to us to make the process of writing programs easier. To grasp the creation of objects and the use of object reference variables. To be familiar with the services provided by the String class. To know how the java standard class library is organized into packages. To be familiar with the services provided by the Random and Math class. To grasp ways to format output using the NumberFormat and DecimalFormat
classes. To be familiar with enumerated types. To understand wrapper classes and the concept of autoboxing. To understand components and containers used in graphics user interfaces. To know a label component and the use of images.6+6 We've been using predefined classes.Now we will learn to write our own classes to define objects. To grasp the structure and content of a class definition. To understand the concept of object state using instance data. To know the effect of visibility modifiers on methods and data. To grasp the structure of a method definition, including parameters and return
values. To grasp the structure and purpose of a constructor. To grasp the creation of graphical objects. To understand the concepts needed to create an interactive graphical user
interface.Chapter 5 Conditionals and Loops
Chapter 6 OBJECT-ORIENTED DESIGN
Chapter 7 Arrays
Chapter 8 Inheritance To know some basic GUI components and events.4+4 Now we will examine programming statements that allow us to make decisions and repeat processing steps in a loop. To know the flow of control through a method. To understand Boolean expressions that can be used to make decisions. To grasp to perform basic decision making using if and switch statements. To understand issues pertaining to the comparison of certain types of data. To grasp familiarly to execute statements repetitively using while, do, and for
loops. To understand the concept of an iterator object and use one to read a text file. To know how to draw with the aid of conditionals and loops. To know more GUI components and events.4+4 Now we can extend our discussion of the design of classes and objects To know key issues related to the design of object-oriented software. To techniques for identifying the classes and objects needed in a program. To understand the relationships among classes. To understand the effect on the static modifier on methods and data. To grasp the creation of a formal object interface. Further grasp the definition of enumerated type classes. To grasp issues related to the design of methods, including method
overloading. To know issues related to the design of graphics user interface, including
layout managers.6+3 Arrays are objects that help us organize large amounts of information Define and use arrays for basic data organization. To know bounds checking and techniques for managing capacity. To learn to compare the issues related to arrays as objects and arrays of
objects. To grasp the use of command-line arguments. To grasp the syntax and use of variable-length parameter lists. To be familiar with the creation and use of multidimensional arrays. To be familiar with the ArrayList class and its generic parameter. To know more mouse and keyboard events.6+6 Inheritance is a fundamental object-oriented design technique used to create and organize reusable classes. To know the derivation of new classes from existing ones. To understand the concept and purpose of method overriding. To grasp the design of class hierarchies. To grasp the issue of visibility as it relates to inheritance. To have the ability to derive on interface from another. To grasp object-oriented design in the context of inheritance. To know the inheritance structure for GUI components. To explore the creation of listeners by extending adaptor classes.Chapter 9 Polymorphism 3+3 Chapter 10 Exceptions 3+3 有关说明：
拟稿（签名）：谢彦麒 Polymorphism is an object-oriented concept that allows us to create versatile software designs To understand polymorphism and explore its benefits. To understand the concept of dynamic binding. To grasp to use inheritance relationships to create polymorphic references. To grasp to use interfaces to create polymorphic references. To grasp sorting and searching using polymorphic implementations. To be familiar with object-oriented design in the context of polymorphism. To know the processing of events as an example of polymorphism. To know more GUI components.Exception handling is an important aspect of object-oriented design To know the purpose of exceptions. To know exception messages and the call stack trace.
To be familiar with the usage of the try-catch statement for handling exception. To understand the concept of exception propagation.
To be familiar with the exception class hierarchy in the Java standard class library. To be familiar with I/O exception and the ability to write text files. To know how to create GUI using mnemonics and tool tips.
To know additional GUI components and containers.核稿（签名）： 审批（签名）： 年 月 日
第四篇：JAVA面向对象程序设计教学大纲
《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.内容
数据类型、变量与常量、表达式、流程控制语句。2.要求
（1）了解：java语言的发展。
（2）掌握：数据类型、变量与常量的定义及使用。（3）熟练掌握：表达式的使用，流程控制语句。3.重点
表达式的使用，流程控制语句。
4.难点
流程控制语句的运用。
第四章 抽象、封装与类（6学时）
1.内容
抽象与封装、Java的类、类的修饰符、域、方法、访问控制符。2.要求
（1）了解：抽象、封装概念，系统定义的类。
（2）掌握：类的修饰符(abstract和final)，域(包括静态域、静态初始化器、最终域和易失域)，方法(包括抽象方法、静态方法、最终方法)。
（3）熟练掌握：用户程序自定义类及创建对象与定义构造函数，访问控制符(包括public、缺省访问控制符、private、protected)的运用。
3.重点
自定义类、创建对象与定义构造函数。
4.难点
四种访问控制符的运用。第五章 继承与多态（4学时）1.内容
Java的继承、多态、Java的重载、构造函数的继承与重载、包及接口的概念。2.要求
（1）了解：继承及多态的概念，Java接口的概念。（2）掌握：Java的方法重载，包的创建及引用。（3）熟练掌握：构造函数的继承与重载。
3.重点
方法的重载、类的继承。4.难点
属性的隐藏、方法的覆盖。第六章 工具类与算法（2学时）
1.内容
语言基础类库(包括Object类、数据类型类、Math类及System类)、Applet类与Applet小程序、数组。
2.要求
（1）了解：Applet类与Applet小程序。（2）掌握：Java语言基础类库。（3）熟练掌握：数组的声明及初始化。3.重点
数组的声明及初始化、数组的应用。4.难点
编写Applet小程序。
第七章 图形用户界面的设计与实现（8学时）
1.内容
图形用户界面概述、GUI标准组件概述及布局设计、Java的事件处理机制。2.要求
（1）了解：图形界面组件之间的层次关系、容器的概念和作用。（2）掌握：图形用户界面程序的基本结构。（3）熟练掌握：事件监听机制。3.重点
图形用户界面程序的基本结构。4.难点
Java的事件处理机制。
第八章 Java高级编程（6学时）
1.内容
异常处理、Java多线程机制、Swing GUI 组件、流式输入输出与文件处理、用Java实现底层网络通信、Java程序对网上资源的访问。
2.要求
（1）了解：例外的概念、Java中线程的基本概念、Java的线程类与Runnable接口及如何在程序中实现多线程、Java输入输出类库及文件的处理与随机访问、使用Java实现底层网络通信、Java程序对网上资源的访问。
3（2）掌握：例外处理机制。
（3）熟练掌握：Swing GUI组件的运用。3.重点
例外处理机制、Swing GUI组件的创建。
4.难点
自定义异常类。
三、课程教学的基本要求
课程教学的基本要求包含三项：上机环节、作业要求、考试方式。1.上机环节
根据课堂讲授的理论，并结合上机操作让学生及时掌握每章节所学的知识，通过实操可加深学生对面向对象程序设计的思想及Java程序设计的领会。
2.作业要求
（1）作业要求：独立思考完成、书写工整、按时交（2）作业量：每次课均布置作业，作业量约2~3题（3）总作业量：约30～40道题 3.考试方式
（1）考试方式：闭卷笔试（2）评定成绩要求：
总成绩=平时成绩×30%+考试成绩×70%
四、本课程与其它课程的联系与分工
1.前期课程：
程序设计基础、计算机网络、C语言程序设计、C++程序设计 2.后续课程：
软件工程、Web应用程序开发
五、建议教材与教学参考书
[1] 印旻.《Java语言与面向对象程序设计》，清华大学出版社 [2] 於东军，杨静宇.《Java程序设计与应用开发》，清华大学出版社 [3] 辛运帏.《Java程序设计》,清华大学出版社 [4] 姜刚.《Java语言程序设计》,人民邮电出版社 [5] 阎菲.《Java程序设计教程》,中国水利水电出版社
第五篇：《Java面向对象程序设计》实验-实验八(输入输出流)
广西科技大学
计通学院
《Java面向对象程序设计》实验
实验八
输入输出流
学生姓名：×××
学
号：×××
班
级：×××
指导老师：×××
专
业：计算机科学与技术
提交日期：×××年×× 月××日
实验报告内容
1． 实验目的
掌握字符输入、输出流用法； 掌握使用Scanner类解析文件； 掌握Console流的使用。
2． 实验内容
实验教材-第12章实验1、2、3 字符输入输出流；Scanner类和Console类。
要求: 完善程序,给出实验结果截图；
完成试验后练习。
3． 程序代码及运行结果：
实验1 举重成绩单
// AnalysisResult.java import java.io.*;import java.util.*;public class AnalysisResult { public static void main(String[] args){ File fRead=new File(“score.txt”);File fWrite=new File(“scoreAnalysis.txt”);try{ Writer out=new FileWriter(fWrite);BufferedWriter bufferWrite=new BufferedWriter(out);Reader in=new FileReader(fRead);BufferedReader bufferRead=new BufferedReader(in);String str=null;
while((str=bufferRead.readLine())!=null){
double totalScore=Fenxi.getTotalScore(str);str=str+“总成绩：”+totalScore;System.out.println(str);bufferWrite.write(str);bufferWrite.newLine();} bufferRead.close();bufferWrite.close();} catch(IOException e){ System.out.println(e.toString());} } }
// Fenxi.java
import java.util.*;public class Fenxi { public static double getTotalScore(String s){ String regex = “[^0123456789.]”;String digitMess = s.replaceAll(regex,“*”);StringTokenizer fenxi = new StringTokenizer(digitMess,“*”);double totalScore=0;while(fenxi.hasMoreTokens()){ double score=Double.parseDouble(fenxi.nextToken());totalScore=totalScore+score;} return totalScore;
} }
// score.txt
姓名：张三，抓举成绩 106kg，挺举 189kg。姓名：李四，抓举成绩 108kg，挺举 186kg。姓名：周五，抓举成绩 112kg，挺举 190kg。
运行结果如图1所示
图1
实验2 统计英文单词 // WordStatistic.java import java.io.*;import java.util.*;public class WordStatistic { Vector
} catch(IOException exp){ System.out.println(exp.toString());} } void setFileName(String name){ file=new File(name);try{ sc=new Scanner(file);sc.useDelimiter(regex);} catch(IOException exp){ System.out.println(exp.toString());} } void WordStatistic(){ try{ while(sc.hasNext()){ String word=sc.next();allWord.add(word);if(!noSameWord.contains(word))noSameWord.add(word);} } catch(Exception e){} } public Vector
} }
// OutputWordMess.java import java.util.*;public class OutputWordMess { public static void main(String[] args){ Vector if(count[n]>count[m]){ String temp=noSameWord.elementAt(m); noSameWord.setElementAt(noSameWord.elementAt(n), m);noSameWord.setElementAt(temp, n);int t=count[m];count[m]=count[n];count[n]=t;} } } for(int m=0;m 运行结果如图2所示 图2 实验3 密码流 // PassWord.java import java.io.*;public class PassWord { public static void main(String[] args){ boolean success=false;int count=0;Console cons;char[] passwd;cons=System.console();while(true){ System.out.print(“输入密码：”); passwd=cons.readPassword(); count++; String password= new String(passwd); if(password.equals(“tiger123”)){ success=true; System.out.println(“您第”+count+“次输入的密码正确！”); break; }else{ System.out.println(“您第”+count+“次输入的密码”+password+“不正确！”); }if(count==3){ System.out.println(“您”+count+“次输入的密码都不正确！”); System.exit(0); } } if(success){ File file=new File(“score1.txt”); try{ FileReader inOne=new FileReader(file); BufferedReader inTow=new BufferedReader(inOne); String s=null; while((s=inTow.readLine())!=null){ System.out.println(s); } inOne.close(); inTow.close(); }catch(IOException ioe){} } } } // score.txt 姓名：张三，抓举成绩 106kg，挺举 189kg。姓名：李四，抓举成绩 108kg，挺举 186kg。姓名：周五，抓举成绩 112kg，挺举 190kg。 运行结果如图3所示 图3 4． 实验后的练习： 实验1 有如下格式的成绩单（文本格式）score.txt。姓名：张三，数学72分，物理67分，英语70分。姓名：李四，数学92分，物理98分，英语88分。 姓名：周五，数学68分，物理80分，英语77分。要求按行读入取成绩单，并在该行的后面尾加上该同学的总成绩，然后再将该行写入到一个名字为scoreAnalysis.txt的文件中。// AnalysisResult.java import java.io.*;import java.util.*;public class AnalysisResult { public static void main(String[] args){ File fRead=new File(“score.txt”);File fWrite=new File(“scoreAnalysis.txt”);try{ Writer out=new FileWriter(fWrite,true);BufferedWriter bufferWrite=new BufferedWriter(out);Reader in=new FileReader(fRead);BufferedReader bufferRead=new BufferedReader(in);String str=null; while((str=bufferRead.readLine())!=null){ double totalScore=Fenxi.getTotalScore(str);str=str+“总分：”+totalScore;System.out.println(str);bufferWrite.write(str);bufferWrite.newLine();} bufferRead.close();bufferWrite.close(); } catch(IOException e){ System.out.println(e.toString());} } } // Fenxi.java import java.util.*;public class Fenxi { public static double getTotalScore(String s){ Scanner scanner=new Scanner(s);scanner.useDelimiter(“[^0123456789.]+”);double totalScore=0;while(scanner.hasNext()){ try{ double score=scanner.nextDouble();totalScore=totalScore+score;} catch(InputMismatchException exp){ String t=scanner.next();} } return totalScore;} } // score.txt 姓名：张三，数学72分，物理67分，英语70分。姓名：李四，数学92分，物理98分，英语88分。姓名：周五，数学68分，物理80分，英语77分。 运行结果如图4所示 图4 实验2 按字典序输出全部不相同的单词。// Dictionary.java import java.util.*;public class Dictionary { public static void main(String args[]){ Vector WordStatistic statistic=new WordStatistic(); statistic.setFileName(“hello.txt”); statistic.WordStatistic();//statistic调用WordStatistic()方法 allWord=statistic.getAllWord(); noSameWord=statistic.getNoSameWord(); System.out.println(“共有”+allWord.size()+“个英文单词”); System.out.println(“有”+noSameWord.size()+“个互不相同英文单词”); System.out.println(“按字典顺序排列:”); String s[]=new String [noSameWord.size()]; for(int i=0;i s[i]=noSameWord.elementAt(i); } Arrays.sort(s); for(int i=0;i System.out.println(s[i]+“ ”); } } } 运行结果如图5所示 图5 实验3 编写一个程序，程序运行时，要求用户输入的密码是：hello。如果用户输入了正确的密码。程序将输出“你好，欢迎你！”。程序允许用户2次输入的密码不正确，一旦超过2次，程序将立刻退出。// PassWord.java import java.io.*;import java.util.Scanner;public class PassWord{ public static void main(String args[]){ int count=0;Console cons;String passwd;Scanner sc=new Scanner(System.in);//cons=System.console(); while(true){ System.out.print(“输入密码:”); passwd=sc.next();// count++; String password=new String(passwd); if(password.equals(“hello”)){ System.out.println(“你好，欢迎你！”); break; } else{ System.out.println(“您第”+count+“次输入的密”+password+“不正确”); } if(count==3){ System.out.println(“您”+count+“次输入的密码都不正确”); System.exit(0); } } } } 运行结果如图6所示 图6 5． 实验心得和体会 这次实验中，我感觉比较难理解和掌握的就是Console类 了，在实验3 密码流的代码在eclipse中运行出错如下图所示： 就是输入不了密码,后来通过找寻解决方法,才知道了在JDK 6中java.io.Console类专用来访问基于字符的控制台设备,然后使用cmd命令提示符来运行就可以输入密码和显示结果了。 通过这次实验，大概了解了字符输入、输出流用法，如何去使用Scanner类解析文件，对Console类的使用有个大概的认知。总而言之，这次实验收获蛮大的，敲代码的效率比以往提高了，出错率也少了。
点击咨询 