テキスト形式のボーエンの始まり：（2点）
| プロジェクト |
コンテンツ |
| 「オブジェクト指向プログラミング（Javaの）」 |
https://www.cnblogs.com/nwnu-daizh/ |
| どこの仕事でこの要件 |
https://www.cnblogs.com/nwnu-daizh/p/11552848.html |
| ジョブの学習目標 |
|
エッセイボーエン本文の内容は次のとおりです。
パートI：第IV章は、理論的な知識をまとめた（20ポイント）
プログラミングオブジェクト指向プログラミングの概要：プログラミングオブジェクト指向プログラミング（OOP）は、今日のプログラミングパラダイムの主流であり、オブジェクト指向プログラミングは、オブジェクトから構成され、実現する機能部と、ユーザの特定の部分を構成する各オブジェクトは、開示された隠れ標準ライブラリからのオブジェクトの多くのプログラムは、いくつかのカスタム一般的に私たちのオブジェクト指向プログラミングを支援するためのクラス、カプセル化、継承の構文とコンセプトを提供があります。プロセス指向のプログラミングにおいて、データ上のデータと操作が分離されているので、このアプローチは、プロシージャおよび関数にデータを渡す必要がある;、オブジェクト指向プログラミングと同一のデータ構造にそれらの動作に属するデータそのプログラム設計の必然的なプロセスが直面する多くの問題を解決するために、すべて1人の統合体でデータや操作、。いわゆるオブジェクト指向プログラムは、特定の物事との具体的な方法の私達のモジュラー、オブジェクト指向、特性を単一のクラスに、これらの特性により、何らかのアクションを達成することです。
1.オブジェクト指向のカプセル化、継承、多型の三つの特徴。
カプセル化：および行動データは、パッケージ内に組み合わされ、そしてこの方法は、直接クラスフィールドの他のクラスのインスタンスにアクセスできないように、ユーザは、オブジェクトデータの実装、パッケージにキーを隠し。
ドメインと呼ばれるデータオブジェクトの例として、プロセスがデータを操作する方法と呼ばれているが、クラスのそれぞれの特定のインスタンスのために設定された閾値の具体例を有し、このオブジェクトの現在の状態は、値の集合です。
継承：Javaでクラスを拡張して、別のプロセスのクラスを作成するには、すべてのクラスがオブジェクトから派生しています。拡張されたクラスのすべての属性とメソッドを拡張した後に既存のカテゴリ、新しいクラスを拡張するとき。
2.オブジェクトの三つの特徴：オブジェクトの挙動、状態オブジェクト、オブジェクトIDは。
クラスとオブジェクト間の関係：クラスは、テンプレートオブジェクトであり、オブジェクトは、クラスのインスタンスであり、クラスはオブジェクトのみで使用することができます。
依存、重合、継承：クラス間の関係。
作曲クラス：プロパティ、メソッド、
3.事前に定義されたクラス：オブジェクトが最初に構築されている必要があり、オブジェクトを使用して、その初期状態を指定します。コンストラクタは、構築したオブジェクトを初期化するために、特別な方法であり、コンストラクタの名前は、同じクラス名でなければなりません
生成オブジェクトフォーマット：オブジェクトのクラス名の名前=新しいクラス名（）。
オブジェクトがインスタンス化され、直接使用されていない場合は、ヌル・ポインタ例外は、使用中に発生します。
4.JavaクラスライブラリLocaiDate（カレンダー表記）クラス：あなたはLOCALDATEオブジェクトを持っていたら、年、月、日を取得getDayOfMonth方法getYearメソッド、getMonthValueを、使用することができます。LOCALDATE plusDaysメソッドで新しいオブジェクトを取得します。
ユーザ定義クラス：Employeeクラスを使用し、ソースファイルが複数、
コンストラクタの開始：コンストラクタと他の方法は重要な違いがあり、常にコンストラクタnew演算子の実装を伴うがインスタンスフィールドをリセットする目的を達成するためにではなく、オブジェクトのコンストラクタへの既存の呼のために、と呼ばれています。コンストラクタと名前のクラス、各クラスが複数の構成を持つことができ、設定は上記のパラメータの1、0またはそれ以上を有していてもよく、コンストラクタは常に新しい演算子と呼ばれるコンストラクタを伴って、値を返しません。
コンストラクタのクラスの明確な定義がない場合、メソッドはクラスに、引数なしでコンストラクタが生成され、属性クラスの初期化、クラスのコンストラクタ、ノーリターン値型宣言と同じ名前で構成されていてもよいですコンストラクタはオーバーロードできますが、それぞれが少なくとも1つのクラスのコンストラクタを持っています。
（暗黙的）及び暗黙のパラメータ（明示的な）パラメータが明示的に指定：操作対象とそのアクセスドメインの例として、暗黙のパラメータは明らかメソッド名Employeeクラスのオブジェクト、メソッドの名前の後の括弧内に配置明示的なパラメータ値、カラムの前に現れますメソッド宣言に、各方法では、キーワードは、これは、暗黙のパラメータを表すJavaのキーワードを使用し、これは。メソッド」を介して呼び出すことができる現在のオブジェクト、「この。プロパティ」このクラスの特性を表すことができますこの（）形式によって、このクラスのコンストラクタを呼び出すことが、呼び出し時に、最初の行のコンストラクタに必要と「このクラスは、他のメソッドを呼び出すことができます。。
パッケージの利点：内部実装は、クラスのメソッドに加えて、私は他のコードには影響しませんが、変更することができます。エラーチェックを行うことが可能な方法が、ドメインの直接の割り当てを変更すると、これらのプロセスではありません。
プライベートメソッド：プライベートメソッドを実装するためには、単に公共のキーワードプライベートを変更します。カプセル化クラス：プライベートキーの変更を通じて、プロパティが直接外部の呼び出し転送することができない、とだけ限り、プロパティはパッケージ化されなければならないとして、getterまたはsetterメソッドにより行うことができます。
6.参照によって渡されるクラスの参照データ型に属する、使用権の移転ヒープメモリ。
7.finalインスタンスフィールド：オブジェクトが構築されている場合の例ドメインが最終的として定義することができる、このフィールドは、最終的な印加電界修飾子最も基本的なタイプのフィールドまたは不変クラスを初期化しなければなりません。変数が一定になるので、プログラム・コードを変更しないように、最終的なデータメンバ変数の前に添加。public static finalの使用は、グローバル定数を宣言することがあります。
8.静的フィールド、および静的メソッド。
静的フィールド（NEXTID）：クラスのフィールドと呼ばれるスタティックドメインカップ。
静的定数：例PI = 3.14
静的メソッド：このメソッドを呼び出すと、静的なキーワードを省略することができます、あなたはEmployeeクラスのオブジェクト参照を使用する必要があります。
ファクトリメソッド、mainメソッド。
9.オブジェクトの構造：
Javaで文字列を特別なクラス、文字列の複製は、直接使用することができるにも工法によってインスタンス化することができ、前者はオブジェクトの1つのインスタンスを参照し、このオブジェクトのインスタンスを再利用することができ、インスタンス化された2つのオブジェクトを生成するました前記スペースは、equalsメソッド文字列の内容と比較して、スパムである、と「==」2つの比較文字列のアドレス値です。一度文字列の内容を変更することはできません宣言しました。
宣言された静的プロパティとメソッドは静的な属性はすべてのオブジェクトによって共有されている、あなたはそれを操作することができ、クラス名によって直接呼び出すことができます。
あなたは、クラスオブジェクトの生成を制限する必要がある場合は、工事の方法は、民営化することができます。
オープンスペースと二段階のアレイとして配列を宣言分割するオブジェクトの配列を使用します。アレイ内の各要素のコンテンツのためのスペースを開放した後にヌルです。
10.パッケージ：
クラスのインポート：
内部クラスは、外部からのアクセスプライベートクラスの別のクラス、内部クラス簡単操作のクラス内で定義されます。メソッドを宣言するために、クラス内のパラメータのアクセス方法は、あなたが最後のキーワードの前にパラメータを追加する必要があります。
継承はextendsキーワードを、あなたはサブクラスに親クラスのメンバーを継承することができますによって実現される機能の既存のクラスを拡張することができます。サブクラスは最初の親クラスの引数なしのコンストラクタを呼び出します前に実行するJavaコンストラクタが、その目的は、初期化を行うために、親クラスのメンバーを継承することです。親クラスは、メソッドのような複数のコンストラクタを有する場合、スーパーサブクラスコンストラクタの特定の構成（）そのキーワードによって呼び出されます。
この（）メソッドは、同じクラス内の他の構成を呼び出すために使用されているスーパー（）はコンストラクタサブクラスから親クラスのコンストラクタを呼び出すために使用されます。その後、このクラスの親クラスから見つからない場合は、このクラスは今、この呼び出しのプロパティとメソッドを使用している場合を探します、スーパーの使用は、親クラスからプロパティとメソッドを見つける必要があります。この（）とスーパー（）という点で類似している：コンストラクタに対応するどちらのコンストラクタのオーバーロードが正しく実行されたときに指定されたパラメータの数とタイプに応じて、どちらも、コンストラクタに書き込まれなければなりません最初の行は、それがこのような理由のために正確である、この（）、スーパー（）は同じコンストラクタで同時に存在することはできません。
過負荷（オーバーロード）はパラメータの数または同じ名前を指すが、方法の異なる種類の同じクラスで定義され、従って、Javaは、メソッド呼び出しの対応するパラメータの数や種類に基づくことができます。
書き換え（オーバーライド）名前、番号、およびパラメータの種類は、親クラスをオーバーライドするために使用される方法のうちのサブクラスで同じ親クラスのメソッドである定義されています。
親クラスは、クラスのオーバーライドをキルトしたくない場合は、親クラスの最後のキーワードの前に追加することができます。
すべてのクラスはObjectクラスから継承します。良いクラスは、）（ハッシュコード（）3番目の方法に等しい）（オブジェクトクラスのtoStringをオーバーライドする必要があり、すべてのオブジェクトは、オブジェクト・クラスまでの移行であってもよいです
抽象クラスは直接オブジェクトを生成するために使用することはできませんが、多型が運営するオブジェクトをインスタンス化する必要があります。抽象クラスのメソッドは、一方が他方には抽象メソッドが抽象キーワードで始まりで、一般的な方法で、二つのタイプに分けられます。抽象メソッドは、メソッド本体を定義していませんが、新しいクラスを定義する抽象クラスから派生しておきたいです。
インターフェースはメソッドとグローバル定数の集合である、インターフェースは、サブクラスによって実装されなければならない、インターフェースは、サブクラスは、同時に複数のインタフェースを実装することができ、同時に複数のインタフェースを継承することができます。
Javaは多重継承クラスを許可しますが、複数のインタフェースを可能にしません。
多型Javaは、（自動）上方遷移および下方遷移（必須）にオブジェクト。
instanceofはキーワードによってオブジェクトがどのクラスに属するかを決定することができます。
匿名内部クラスの役割は、名前を持たない内部クラスのオブジェクトを作成するために使用可能な、およびクラスメンバにアクセスするためにそれを使用します
パッケージ内のクラス：
パッケージにクラスであるJavaのパッケージのキーワードを使用します。
既存のパッケージをインポートすることができ、Javaのimport文を使用します。
アクセス制御権におけるJavaは4種類、すなわちプライベート、デフォルト、保護、公衆に分かれています。
パートII：実験の部
実験名：オブジェクトを用いた実験の3種類の定義と使用
1.目的：
（1）オンラインテスト環境のためのPTAのプラットフォームに精通しています。
（2）ユーザ定義の理解クラス。
（3）オブジェクト宣言を把握します。
（4）オブジェクトを初期化するコンストラクタを使用することを学びます。
（5）マスターを使用してのクラス属性および方法を使用して、
（6）パッケージとインポートステートメントの使用を習得します。
3.実験の手順と内容：
実験1タスク1（10ポイント）
コードは以下の通りであります：
インポートjava.util.Scanner;
パブリッククラスシェン{
パブリック静的無効メイン（文字列[] args）{
// TODO自動生成方法スタブ
=新しいスキャナ（System.in）スキャナ。
System.out.println（ "あなたのIDの入力をしてください："）;
ストリングS1 = in.nextLine（）。
文字列S2、S3、S4;
S2 = s1.substring（6、10）。
S3 = s1.substring（10、12）。
S4 = s1.substring（12、14）。
System.out.println（S2 + " - " + S3 + " - " + S4）。
}
}
次のように図の実行結果は以下の通りでした。
実験1タスク2（25点）
コードは以下の通りであります：
輸入java.io.BufferedReader;
輸入java.io.FileReader。
インポートにjava.io.IOException;
輸入はjava.util.ArrayList;
インポートjava.util.Scanner;
パブリッククラスメイン{
//プライベート静的学生の学生[];
プライベート静的ArrayListに<学生>リスト。
パブリック静的無効メイン（文字列[] args）{
リスト=新規のArrayList <>（）;
=新しいスキャナ（System.in）でスキャナ。
してみてください{
readFileの（ "studentfile.txt"）;
System.out.println（ "请选择操作、1按姓名、号学2按、3退出"）。
私はint型。
一方、（（I = in.nextInt（））= 3！）{
スイッチ（I）{
ケース1：
のSystem.out.println（ "请输入姓名"）。
文字列名= in.next（）。
学生の学生= findStudentByName（名）;
ブレーク;
}
BREAK;
デフォルト：
}
}キャッチ（IOExceptionを電子）{
// TODO自动生成的キャッチ块
e.printStackTrace（）;
}最後に{
in.close（）。
}
}
パブリック静的ボイドreadFileの（文字列のパス）にIOException {スロー
FileReaderのリーダーが=新規FileReader（パス）。
BufferedReaderのBR =新しいBufferedReaderの（リーダー）。
文字列の結果。
（！（結果= br.readLine（））= NULL）{ながら、
学生の学生=新学生（）;
student.setName（（13れresult.substring））;
student.setID（result.substring（ 0,12））;
List.add（学生）。
}
br.close（）。
}
パブリック静的学生findStudentByName（文字列名）{
（学生学生：リスト）について{
場合（。student.getName（）のequals（名））{
リターン学生。
}
}
ヌルを返します。
}
パブリック静的学生findStudentById（文字列Id）の{
用（学生学生：リスト）{
IF（。student.getID（）に等しい（ID））{
戻り学生。
}
}
はnullを返します。
}
}
クラスの学生{
プライベート文字列名;
プライベート文字列ID;
パブリック文字列のgetName（）{
名前を返します。
}
パブリック文字列のtoString（）{
// TODO自动生成的方法存根
公共ボイドのsetName（文字列名）{
this.name =名前;
}
パブリック文字列のgetId（）{
IDを返します。
}
公共ボイドSETID（文字列ID）{
ID ID =。
}
@Override
リターン"姓名是：" +名+ "学号是：" + ID。
}
}
次のように図の結果は以下のとおりです。
実験2試験手順1（10分）
次のように（1）コードです。
import java.time.*;
/**
* This program tests the Employee class.
* @version 1.13 2018-04-10
* @author Cay Horstmann
*/
public class EmployeeTest
{
public static void main(String[] args)
{
//构造一个Employee数组，并填入三个雇员对象
Employee[] staff = new Employee[3];
staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
// 用Employee类的raiseSalary方法将每个雇员的薪水提高5%
for (Employee e : staff)
e.raiseSalary(5);
// 调用getName方法、getSalary方法和getHireDay方法将每一个雇员的信息打印出来
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
}
class Employee
{
private String name; //实例域定义
private double salary;
private LocalDate hireDay;
public Employee(String n, double s, int year, int month, int day) //构造器定义
{
name = n;
salary = s;
hireDay = LocalDate.of(year, month, day);
}
public String getName() //实例域name的访问器方法
{
return name;
}
public double getSalary() //实例域salary的访问器方法
{
return salary;
}
public LocalDate getHireDay() //实例域HireDay的访问器方法
{
return hireDay;
}
//调用raiseSalary方法的对象的salary实例域设置为新值
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下图：
（2）
EmployeeTest.java程序代码如下：
public class EmployeeTest
{
public static void main(String[] args)
{
// 用三个employee对象填充staff数组
Employee[] staff = new Employee[3];
staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
// raise everyone's salary by 5% 给每人涨5%的工资
for (Employee e : staff) //进行foreach循环
e.raiseSalary(5);
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
}
运行结果如下图：
Employee.java程序代码如下：
import java.time.LocalDate;
public class Employee {
private String name; //实例域定义
private double salary; //实例域定义
private LocalDate hireDay; //实例域定义
public Employee(String n, double s, int year, int month, int day) //构造器的定义
{
name = n;
salary = s;
hireDay = LocalDate.of(year, month, day);
}
public String getName() //实例域name的访问器方法
{
return name;
}
public double getSalary() //实例域Salary的访问器方法
{
return salary;
}
public LocalDate getHireDay() ////实例域HireDay的访问器方法
{
return hireDay;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下图：
（3）程序代码如下：
import java.util.Scanner;
public class student {
String name;
String sex;
double javascore;
public static void main(String[] args) {
System.out.println("请输入学生人数");
Scanner su = new Scanner(System.in);
int totalStudent = su.nextInt();
student[] stus= new student[totalStudent];
for(int i=0;i<totalStudent;i++) {
student s =new student();
stus[i]=s;
System.out.println("请输入第+“i"+"个学生的姓名");
s.name = su.next();
System.out.println("请输入第+“i"+"个学生的性别");
s.sex = su.next();
System.out.println("请输入第+“i"+"个学生的java成绩");
s.javascore = su.nextDouble();
}
printstudent(stus);
su.close();
}
public static void printstudent(student[] s) {
System.out.println("姓名\t性别\tjava成绩");
for(int i=0;i<s.length;i++) {
System.out.println(s[i].name+"\t"+s[i].sex+"\t"+s[i].javascore);
}
}
}
运行结果如下图：
实验2 测试程序2（5分）
程序代码如下：
/**
* This program demonstrates static methods.
* @version 1.02 2008-04-10
* @author Cay Horstmann
*/
public class StaticTest
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects
var staff = new Employee[3]; //构造了一个Employee 数组，并填入三个雇员对象
staff[0] = new Employee("Tom", 40000);
staff[1] = new Employee("Dick", 60000);
staff[2] = new Employee("Harry", 65000);
// print out information about all Employee objects
for (Employee e : staff) //调用getName 方法，getId方法和getSalary方法将每个雇员的信息打印出来
{
e.setId();
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary());
}
int n = Employee.getNextId(); // calls static method
System.out.println("Next available id=" + n);
}
}
class Employee
{
private static int nextId = 1;
private String name; //实例域定义
private double salary;
private int id;
public Employee(String n, double s) //构造器定义
{
name = n;
salary = s;
id = 0;
}
public String getName() //实例域name的访问器方法
{
return name;
}
public double getSalary() //实例域salary的访问器方法
{
return salary;
}
public int getId() //实例域id的访问器方法
{
return id;
}
public void setId()
{
id = nextId; // set id to next available id
nextId++;
}
public static int getNextId() //实例域NextId的访问方法
{
return nextId; // returns static field
}
public static void main(String[] args) // unit test
{
var e = new Employee("Harry", 50000);
System.out.println(e.getName() + " " + e.getSalary());
}
}
运行结果如下图：
实验2 测试程序3（5分）
程序代码如下：
/**
* This program demonstrates parameter passing in Java.
* @version 1.01 2018-04-10
* @author Cay Horstmann
*/
public class ParamTest
{
public static void main(String[] args)
{
/*
* Test 1: Methods can't modify numeric parameters（方法不能修改数值参数）
*/
System.out.println("Testing tripleValue:");
double percent = 10;
System.out.println("Before: percent=" + percent);
tripleValue(percent); //调用方法tripleSalary
System.out.println("After: percent=" + percent);
/*
* Test 2: Methods can change the state of object parameters （方法可以更改对象参数的状态）
*/
System.out.println("\nTesting tripleSalary:");
var harry = new Employee("Harry", 50000);
System.out.println("Before: salary=" + harry.getSalary());
tripleSalary(harry); //调用方法tripleSalary
System.out.println("After: salary=" + harry.getSalary());
/*
* Test 3: Methods can't attach new objects to object parameters
*/
System.out.println("\nTesting swap:");
var a = new Employee("Alice", 70000); //定义一个类型为var的a，并进行初始化
var b = new Employee("Bob", 60000);
System.out.println("Before: a=" + a.getName());
System.out.println("Before: b=" + b.getName());
swap(a, b); //交换函数
System.out.println("After: a=" + a.getName());
System.out.println("After: b=" + b.getName());
}
public static void tripleValue(double x) // doesn't work（不工作）
{
x = 3 * x;
System.out.println("End of method: x=" + x);
}
public static void tripleSalary(Employee x) // works
{
x.raiseSalary(200); //x的调用
System.out.println("End of method: salary=" + x.getSalary());
}
//x和y进行交换
public static void swap(Employee x, Employee y)
{
Employee temp = x;
x = y;
y = temp;
System.out.println("End of method: x=" + x.getName());
System.out.println("End of method: y=" + y.getName());
}
}
class Employee // simplified Employee class
{
private String name; //实例域定义
private double salary;
public Employee(String n, double s) //构造器定义
{
name = n;
salary = s;
}
public String getName() //实例域name的访问器方法
{
return name;
}
public double getSalary() ////实例域Salary的访问器方法
{
return salary;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下图：
实验2 测试程序4（5分）
程序代码如下：
import java.util.*;
/**
* This program demonstrates object construction.
* @version 1.02 2018-04-10
* @author Cay Horstmann
*/
public class ConstructorTest
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects (用三个employee对象填充staff数组 )
var staff = new Employee[3];
staff[0] = new Employee("Harry", 40000);
staff[1] = new Employee(60000);
staff[2] = new Employee();
// print out information about all Employee objects （打印有关所有员工对象的信息 ）
for (Employee e : staff) //foreach循环
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary());
}
}
class Employee
{
private static int nextId; //静态域nextId
private int id;
private String name = ""; // instance field initialization（实例字段intialization）
private double salary;
// static initialization block （静态intialization块）
static
{
var generator = new Random();
// set nextId to a random number between 0 and 9999 （将nextId设置为0到999之间的随机值）
nextId = generator.nextInt(10000);
}
// object initialization block （对象intialization块）
{
id = nextId;
nextId++;
}
// three overloaded constructors //三个重载的构造
public Employee(String n, double s)
{
name = n;
salary = s;
}
public Employee(double s)
{
// calls the Employee(String, double) constructor
this("Employee #" + nextId, s); //this用来引用当前对象
}
// the default constructor //错误的构造器
public Employee()
{
// name initialized to ""--see above
// salary not explicitly set--initialized to 0
// id initialized in initialization block
}
public String getName() //实例域name的访问器方法
{
return name;
}
public double getSalary() //实例域Salary的访问器方法
{
return salary;
}
public int getId() //实例域Id的访问器方法
{
return id;
}
}
运行结果如下图所示：
实验2 测试程序5（5分）
4-6程序代码如下：
import com.horstmann.corejava.*;
// the Employee class is defined in that package （Employees类在该包中定义）
import static java.lang.System.*; //静态导入System类
/**
* This program demonstrates the use of packages.
* @version 1.11 2004-02-19
* @author Cay Horstmann
*/
public class PackageTest
{
public static void main(String[] args)
{
// because of the import statement, we don't have to use
// com.horstmann.corejava.Employee here
var harry = new Employee("Harry Hacker", 50000, 1989, 10, 1);
harry.raiseSalary(5);
// because of the static import statement, we don't have to use System.out here
out.println("name=" + harry.getName() + ",salary=" + harry.getSalary());
}
}
运行结果如下图：
4-7程序代码如下：
package com.horstmann.corejava; //将类放入包中
// the classes in this file are part of this package （这个文件中的类就是这个包中的一部分）
import java.time.*; //java.time包的引入
// import statements come after the package statement （import语句位于package语句之后）
/**
* @version 1.11 2015-05-08
* @author Cay Horstmann
*/
public class Employee
{
private String name; //实例域定义
private double salary;
private LocalDate hireDay;
public Employee(String name, double salary, int year, int month, int day) //构造器定义
{
this.name = name; //this用来引用当前对象
this.salary = salary;
hireDay = LocalDate.of(year, month, day);
}
public String getName() //实例域name的访问器方法
{
return name;
}
public double getSalary() //实例域Salary的访问器方法
{
return salary;
}
public LocalDate getHireDay() //实例域HireDay的访问器方法
{
return hireDay;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下图：
4. 实验总结：（10分）
通过第四周的学习，掌握类的定义,熟悉属性、构造函数、方法的作用,掌握用类作为类型声明变量和方法返回值；理解类和对象的区别,类可以看做一个模板，我们可以根据类来创建很多的对象，而这些对象都具有我们在类中定义的方法和属性，类是抽象的，而对象是具体的。可以通过new关键字去实例化对象。还有掌握构造函数的使用,熟悉通过对象名引用实例的方法和属性;理解方法中的形参和实参传递在传递基本类型和引用类型的的差异;理解sstatic修饰符对类、类成员变量及类方法的影响 。通过编程和上机实验理解加java语言是如何体现面向对象编程基本思想,了解类的封装方法,以及加何创建类和对象,了解成员变量和成员方法的特性,掌握O0P方式进行程序设计的方话,了解共的继承性和多态性的作用。