第5章面向对象编程（上）_编写程序,包含类dog和testdog-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_39458365/article/details/133499187

本文围绕Java面向对象编程展开，介绍了类和对象、属性和方法、内存管理等概念，阐述了面向对象的三大特征。详细讲解了类的定义、对象的创建和使用，还涉及包的管理、方法参数传递等内容，并给出多个相关练习及代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本章内容

第一节类和对象

第二节对象的属性和方法

第三节 Java内存管理和垃圾回收

第四节类的封装

第五节 this关键字

第六节声明和使用构造器

第七节包的管理

学习面向对象内容的三条主线

1.java类及类的成员

2.面向对象的三大特征

3.其它关键字

何谓“面向对象”的编程思想？

面向对象与面向过程

面向对象(OOP)与面向过程

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为。面向对象，将功能封装进对象，强调具备了功能的对象。

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象的三大特征

封装 (Encapsulation)

继承 (Inheritance)

多态 (Polymorphism)

OOP: Object Oriented Programming

面向过程：procedure oriented programming

面向对象的思想概述

程序员从执行者转化成了指挥者。

完成需求时：

先去找具有所需功能的对象来用。

如果该对象不存在，那么创建一个具有所需功能的对象。

这样简化开发并提高复用。

类(class)和对象(object)是面向对象的核心概念。

类是对一类事物描述，是抽象的、概念上的定义

对象是实际存在的该类事物的每个个体，因而也称实例(instance)。

“万事万物皆对象”

类和对象

可以理解为：类 = 汽车设计图；对象 = 实实在在的汽车

面向对象程序设计的重点是类的设计

定义类其实是定义类中的成员(成员变量和成员方法)

java类及类的成员

面向对象是一种的程序设计方法，其基本思想是使用对象和类等基本概念来进行程序设计。

类是对现实世界事物的抽象定义

属性：对应类中的成员变量

行为：对应类中的成员方法

Field = 属性 = 成员变量，Method = (成员)方法 = 函数

类的语法格式

修饰符 class 类名 {

属性声明;

方法声明;

}

说明：修饰符public：类可以被任意访问

类的正文要用{ }括起来

举例：

public class Person{

private int age ; //声明私有变量 age

public void showAge(int i) { //声明方法showAge( )

age = i;

}

创建Java自定义类

步骤：

1，定义类（考虑修饰符、类名）,

2，编写类的属性（考虑修饰符、属性类型、属性名、初始化值）

3，编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

练习：

定义Person、Animal、ClassRoom、Zoo等类，加以体会。

对象的创建和使用

对象通过new +构造器语句来创建

引用变量用来引用对象。

例如：

声明Animal类型的引用变量t：

Animal xb;

使用引用变量引用对象：

xb = new Animal();

举例：

public class Animal { public int legs; public void eat(){ System.out.println(“Eating.”); } public viod move(){ System.out.println(“Move.”); } } public class Zoo{ public static void main(String args[]){ Animal xb=new Animal(); xb.legs=4; System.out.println(xb.legs); xb.eat(); xb.move(); } }

类与对象

对象的创建和使用

如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

public class Zoo{ public static void main(String args[]){ Animal xb=new Animal(); Animal xh=new Animal(); xb.legs=4; xh.legs=0; System.out.println(xb.legs); //4 System.out.println(xh.legs); //0 xb.legs=2; System.out.println(xb.legs); //2 System.out.println(xh.legs); //0 } }

提示

类的访问机制：

在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过。）

在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。

如：new Person().shout();

使用情况

如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。

我们经常将匿名对象作为实参传递给一个方法调用。

练习

练习1：

编写一个Student类，包含name、gender、age、id、score属性，分别为String、String、int、int、double类型。

类中声明一个say方法，返回String类型，方法返回信息中包含所有属性值。

在另一个TestStudent类中的main方法中，创建Student对象，并访问say方法和所有属性，并将调用结果打印输出。

public class Student{ private String name; private String gender; private int age; private int id; private double score; public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setGender(String gender){ this.gender = gender; } public String getGender(){ return gender; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } public void setId(int id){ this.id = id; } public int getId(){ return name; } public void setScore(double score){ this.name = name; } public double getScore(){ return score; } public String say(){ return “Person[name=” + name + “, gender=” + gender + “, age=” + age + “, id=” + id + “, score=” + score“]”; } }

练习2：

编写一个Dog类，包含name、age、weight属性

类中声明一个say方法，返回String类型，方法返回信息中包含所有属性值。

在另一个TestDog类中的main方法中，创建Dog对象，并访问say方法和所有属性，将调用结果打印输出。

public class Dog{ private String name; private int age; private float weight; public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } public void setWeight(float weight){ this.weight = weight; } public double getWeight(){ return weight; } public String say(){ return “Dog[name=” + name + “, age=” + age + “, weight=” + weight“]”; } }

第二节对象的属性和方法

Car c3 = new Car();

Car c1 = new Car();

c1.name = "奔驰";

c1.color = "白色";

c1.tyre = 4;

Car c2 = new Car();

c2.name = "宝马";

c2.color = "黑色";

c2.tyre = 4;

类的成员之一：属性

对象的属性，也称为成员变量，又称为实例变量。

对象属性的初始化，即初始赋值，有以下同两种方式：

默认初始化赋值：对象被创建时，不同类型的属性首先被赋予不同的缺省值。

显式初始化赋值：如果在类中声明属性时指定了初始值，那么在对象被创建时，相应的属性就被显式地赋予此初始值。

语法格式：

修饰符数据类型属性名 =初值 ;

对象属性的缺省初始化赋值

对象的产生

class Person{

int age;

void shout(){

System.out.println(“oh,my god! I am ” + age);

}

Person p1 = new Person();执行完后的内存状态

对象的使用

class TestPerson{ public static void main(String[] args) { //程序运行的内存布局如下图 Person p1 = new Person(); Person p2 =new Person(); p1.age = -30; p1.shout(); p2.shout(); } }

根据代码，画出内存图

class Car{ String color = "red"; int num = 4; void show(){ System.out.println("color="+color+"..num="+num); } } class TestCar { public static void main(String[] args) { Car c1 = new Car(); //建立对象c1 Car c2 = new Car(); //建立对象c2 c1.color = "blue"; //对对象的属性进行修改 c1.show(); //使用对象的方法 c2.show(); } }

对象内存结构

补：变量的分类：成员变量与局部变量

在方法体外，类体内声明的变量称为成员变量。

在方法体内部声明的变量称为局部变量。

注意：二者在初始化值方面的异同:

同：都有生命周期

异：局部变量除形参外，需显式初始化。

成员变量（属性）和局部变量的区别？

·成员变量：

成员变量定义在类中，在整个类中都可以被访问。

成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。

成员变量有默认初始化值。

成员变量的权限修饰符可以根据需要，选择任意一个

·局部变量：

局部变量只定义在局部范围内，如：方法内，代码块内等。

局部变量存在于栈内存中。

作用的范围结束，变量空间会自动释放。

局部变量没有默认初始化值，每次必须显式初始化。

局部变量声明时不指定权限修饰符

练习

1，改写Dog类，name属性使用缺省初始值，age和weight属性使用显式初始值1和10。

2，在TestDog类的main方法中，创建两个Dog对象，分别调用两对象的say方法，将调用结果打印输出。

3，继续在main方法中，将两个Dog对象的name属性分别设为“京叭 ”和“吉娃娃”，第二个对象的体重设为8。再分别调用两对象的say方法，将调用结果打印输出。,

4，根据输出结果，理解由同一类创建的不同对象的属性的独立性。

方法的参数传递 -引用数据类型的参数传递

方法的参数传递

public class TestTransfer { public static void swap(int a , int b){ int tmp = a; a = b; b = tmp; System.out.println("swap方法里，a的值是" + a + "；b的值是" + b); } public static void main(String[] args) { int a = 6; int b = 9; swap(a , b); System.out.println("交换结束后，变量a的值是" + a + "；变量b的值是" + b); } }

class DataSwap{ public int a; public int b; } public class TestTransfer1 { public static void swap(DataSwap ds){ int tmp = ds.a; ds.a = ds.b; ds.b = tmp; System.out.println("swap方法里，a Field的值是"+ ds.a + "；b Field的值是" + ds.b); } public static void main(String[] args) { DataSwap ds = new DataSwap(); ds.a = 6; ds.b = 9; swap(ds); System.out.println("交换结束后，a Field的值是" + ds.a + "；b Field的值是" + ds.b); } }

第三节 Java内存管理和垃圾回收

JVM内存结构

在执行Java应用程序时，JVM将内存划分为多个不同区域，用以维持程序的运行。

对于Java程序员来说，应了解堆和堆栈的用途：

堆栈：用于临时保存局部变量的值

堆：用于存储对象及其加载的类

所有由代码直接或间接创建的对象均被保存在堆（Heap）内存中。

JVM将堆内存划分为两个部分：垃圾回收区和永久区。

所有创建的对象均被存放在垃圾回收区中，而永久区只用于存放JVM所加载类的信息。

JVM垃圾回收机制

垃圾对象 — 内存中不再被使用的对象

垃圾回收（GC） — JVM自动释放垃圾对象所占内存的机制

如果对象再没有被引用变量引用时，便称之为垃圾，其所占用的内存将很快被JVM回收。

public class TestDog { public static void main(String[] args) { Dog d = new Dog(); System.out.println("Dog d’s weight is " + d.getWeight()); d = null; Dog d1 = new Dog(); System.out.println("Dog d’s weight is " + d1.getWeight()); } }

第四节类的封装

面向对象特征之一：封装和隐藏

使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。

public class Animal { public int legs; public void eat(){ System.out.println(“Eating.”); } public void move(){ System.out.println(“Moving.”); } } public class Zoo{ public static void main(String args[]){ Animal xb=new Animal(); xb.legs=4; System.out.println(xb.legs); xb.eat();xb.move(); } }

信息的封装和隐藏

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；

使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

便于修改，增强代码的可维护性；

public class Animal{ private int legs;//将属性legs定义为private，只能被Animal类内部访问 public void setLegs(int i){ //在这里定义方法 eat() 和 move() if (i != 0 && i != 2 && i != 4){ System.out.println("Wrong number of legs!"); return; } legs=i; } public int getLegs(){ return legs; } } public class Zoo{ public static void main(String args[]){ Animal xb=new Animal(); xb.setLegs(4); //xb.setLegs(-1000); xb.legs=-1000; //非法 System.out.println(xb.getLegs()); } }

四种访问权限修饰符

练习

1.创建程序,在其中定义两个类：Person和TestPerson类。定义如下：

用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。在TestPerson类中实例化Person类的对象b，调用setAge()和getAge()方法，体会Java的封装性。

Person

-age:int

+setAge(i: int)

+getAge(): int

第五节 this关键字

使用this关键字

this关键字可用来区分局部变量和实例变量（属性）

例如： this.name = name;

关键字—this

在java中，this关键字比较难理解，它的作用和其词义很接近。

它在方法内部使用，即这个方法所属对象的引用；

它在构造器内部使用，表示该构造器正在初始化的对象。

this表示当前对象，可以调用类的属性、方法和构

造器

this关键字可用来区分局部变量和实例变量（属性）

例如： this.name = name;

class Person{ // 定义Person类 String name; Person(String name){ this.name = name; } public void getInfo(){ System.out.println("Person类 --> " + this.name) ; } public boolean compare(Person p){ return this.name==p.name; } } public class TestPerson{ public static void main(String args[]){ Person per1 = new Person("张三") ; Person per2 = new Person("李四") ; per1.getInfo() ; // 当前调用getInfo()方法的对象是per1 per2.getInfo() ; // 当前调用getInfo()方法的对象是per2 boolean b = per1.compare(per2); } }

当前正在操作本方法的对象称为当前对象。

使用this，调用属性、方法

class Person{ // 定义Person类 private String name ; private int age ; public Person(String name,int age){ this.name = name ; this.age = age ; } public void getInfo(){ System.out.println("姓名：" + name) ; this.speak(); } public void speak(){ System.out.println(“年龄：” + this.age); } }

1.当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员

2.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性

练习

补充：UML类图

第六节声明和使用构造器

类的成员之三：构造器(构造方法)

构造器的特征

它具有与类相同的名称

它不声明返回值类型。（与声明为void不同）

不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用：创建对象；给对象进行初始化

如：Order o = new Order(); Person p = new Person(Peter,15);

如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造方法中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

构造器

·语法格式：

修饰符类名 (参数列表) {

初始化语句；

}

·举例：

public class Animal {

private int legs;

public Animal() {legs = 4; } //构造器

public void setLegs(int i) { legs = i; }

public int getLegs(){

return legs;

}

创建Animal类的实例：Animal a=new Animal();

//调用构造器，将legs初始化为4。

根据参数不同，构造器可以分为如下两类：

隐式无参构造器（系统默认提供）

显式定义一个或多个构造器（无参、有参）

·注意：

Java语言中，每个类都至少有一个构造器

默认构造器的修饰符与所属类的修饰符一致

一旦显式定义了构造器，则系统不再提供默认构造器

一个类可以创建多个重载的构造器

父类的构造器不可被子类继承

练习

1.在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。

2.修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。

Person

-name:String

+setName(name: String)

+getName(): String

编写两个类，TriAngle和TestTriAngle，其中TriAngle中声明私有的底边长base和高height，同时声明公共方法访问私有变量；另一个类中使用这些公共方法，计算三角形的面积。

构造器重载

l构造器一般用来创建对象的同时初始化对象。如

class Person{ Stringname; int age; publicPerson(String n , int a){ name=n; age=a;} }

l构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。

构造器重载举例：

public class Person{ public Person(String name, int age, Date d) {this(name,age);…} public Person(String name, int age) {…} public Person(String name, Date d) {…} public Person(){…} }构造器重载，参数列表必须不同

使用this调用本类的构造器

classPerson{ // 定义Person类 private String name ; private int age ; publicPerson(){ // 无参构造 System.out.println("新对象实例化"); } public Person(String name){ this(); //调用本类中的无参构造方法 this.name= name ; } public Person(String name,intage){ this(name); // 调用有一个参数的构造方法 this.age= age; } public String getInfo(){ return "姓名："+ name + "，年龄："+ age ; } } this可以作为一个类中，构造方法相互调用的特殊格式

注意：

1.使用this()必须放在构造器的首行！

2.使用this调用本类中其他的构造方法，至少有一个构造方法是不用this的。

构造器重载举例

public class Person { private String name; private int age; private Date birthDate; public Person(String name, int age, Date d) { this.name= name; this.age = age; this.birthDate = d; } public Person(String name, int age) { this(name,age, null); //this.name=name;this.age=age; this.birthDate=null; } public Person(String name,Date d) { this(name,30, d); //this.name=name; this.age=30; this.birthDate=d; } public Person(String name) { this(name, 30); //this.name=name; this.age=30; }}

练习

(1)定义Person类,有4个属性：Stringname; int age;String school;

String major

(2)定义Person类的3个构造方法:

第一个构造方法Person(String

name, int age)设置类的name和age属性

第二个构造方法Person(String

name, int age,

String school)设置类的name,

age 和school属性；

第三个构造方法Person(String

name, int age,

String school, String major)设置类的name,

age ,school和major属性；

(3)在main方法中分别调用不同的构造方法创建的对象，并输出其属性值。

JavaBean

JavaBean是一种Java语言写成的可重用组件。

所谓javaBean，是指符合如下标准的Java类：

Ø类是公共的

Ø有一个无参的公共的构造器

Ø有属性，且有对应的get、set方法

l用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

JavaBean示例

public class TestJavaBean{ private String name; //属性一般定义为private private int age; public TestJavaBean(){} public int getAge(){ return age; } public void setAge(int age){ this.age = age; } public String getName(){ return name; } public void setName(String name){ this.name = name; }

第七节包的管理

关键字—package

package语句 — 告诉编译器我（指所在类）属于哪个包

基本语法：

package[.]*;

包名称的各部分均应由小写字母组成。

如果声明了一个类的所属包，那么应该以该类的全称（带包名的名称）作为其名称。

例如，Person类全称应为com.atguigu.Person

类的全称也称为类的全限定名称(全类名)。

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为：

包对应于文件系统的目录，package语句中，用

“.” 来指明包(目录)的层次；

包通常用小写单词，类名首字母通常大写。

示例

1 package com.aaa; 2 3 public class Person{ 4 public void eat(){} 5 public void sleep(){} 6}

包的作用

防止类的重命名

通常将功能相近的模块组织在同一个包中，用包来划分项目层次

控制访问权限。

关键字—import

l为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。

limport

语句 — 告诉编译器我（指所在类）所用的类位于哪个包

语法格式：

import 包名[.子包名…].

示例

package com.ccc; import com.aaa.*; import com.bbb.Animal; public class TestPerson { public static void main(String args[]) { Person p = new Person(); p.eat(); Animal ani = new Animal(); } }

import语句

注意：

若引入的包为：java.lang，则编译器默认可获取此包下的类，不需要再显示声明。

import语句出现在package语句之后、类定义之前

一个源文件中可包含多个import语句

可以使用import com.* ;语句，表明导入com包下的所有类。而com包下sub子包内的类则不会被导入。import com.sub.*;

import语句不是必需的，可坚持在类里使用其它类的全名

JDK1.5加入import static(静态导入)语句—告诉编译器我（指所在类）所使用的静态成员从哪个类中导入。

编译时使用-d选项

•javac命令提供了一个-d 选项，可用来自动创建class文件所在包的各级子目录。

•运行格式：

javac -d 包目录结构的起始位置> 源文件名.java>

•例如：

javac -d ./ Flyer.java Pet.java

javac -d ./ Bird.java

javac -d ./ TestAbstractInterface.java

练习

1.编写一个Person类归到com.superclass包中；将Student类和Teacher类归到com.subclass包中；将TestPerson类归到test包中。

2.编译并运行该程序。

使用jar命令打包应用程序

•可使用jar命令将应用程序的所有类打包为一个.jar文件以方便部署应用程序

•打包过程如下：

1.创建文本文件，在其中指明主类。例如tempfile.txt：

Main-Class:com.ccc.TestPerson

2.在应用程序相对于包的根目录中，执行jar命令打包程序：

jar cmf tempfile.txt MyProgram.jar ./

•可以在命令行执行.jar类型打包应用程序。例如：

java –jar MyProgram.jar

练习

1.将前面练习的类一起打包到.jar文件中，并运行该.jar文件。

JDK中主要的包介绍

1.java.lang----包含一些Java语言的核心类，如String、Math、Integer、

System和Thread，提供常用功能。

2. java.net----包含执行与网络相关的操作的类和接口。

3. java.io ----包含能提供多种输入/输出功能的类。

4. java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、

使用与日期日历相关的函数。

5. java.text----包含了一些java格式化相关的类

6. java.sql----包含了java进行JDBC数据库编程的相关类/接口

7. java.awt----包含了构成抽象窗口工具集（abstractwindow toolkits）的

多个类，这些类被用来构建和管理应用程序的图形用户界

面(GUI)。

8. java.applet----包含applet运行所需的一些类。

综合练习

1.Room类

–属性：房号、面积、地址

–方法：getDetails 返回String，描述房间详细信息

–构造器：0-3个参数的重载构造器，使用this（）调用

–使用封装

2.TestRoom类

–分别用4个构造器创建4个room对象，打印对象的详细信息

day06_课后练习

第一题：概念辨析

一个类与它的对象之间是什么关系？
如何定义一个类，由哪些部分组成，各个部分的作用是什么？
如何创建一个对象，如何使用该对象？
局部变量和成员变量的区别？
构造方法和成员方法的区别？

第二题：语法练习

语法与技能：
- 类（属性、构造器、方法）、对象、this
- eclipse使用
定义一个圆形Circle类。
- 属性：私有化
  - r：半径
- 构造方法：
  - 无参构造方法
  - 满参构造方法
- 成员方法：
  - get/set方法
  - showArea方法：打印圆形面积
  - showPerimeter方法：打印圆形周长
定义测试类TestCircle：创建Circle对象，并测试。
开发提示：

面向周长公式：2 * 3.14* 半径圆形面积公式：3.14* 半径^2

public class Circle { private double radius; public Circle(double radius) { this.radius = radius; } public Circle() { } public double getRadius() { return radius; } public void setRadius(double radius) { this.radius = radius; } public void showArea(){ System.out.println("半径为：" + radius + "，面积：" + 3.14 * radius * radius); } public void showPerimeter(){ System.out.println("半径为：" + radius + "，周长：" + 2 * 3.14 * radius); } }

public class Test02 { public static void main(String[] args) { Circle c1 = new Circle(1.2); c1.showArea(); c1.showPerimeter(); } }

第三题：语法练习

语法与技能：
- 类（属性、构造器、方法）、对象、this
- eclipse使用
定义一个日期MyDate类。
- 属性：
  - year：年
  - month：月
  - day：日
- 构造方法：
  - 满参构造方法
- 成员方法：
  - get/set方法
  - void showDate方法：打印日期。
  - boolean isLeapYear()方法：判断当前日期是否是闰年
定义测试类：创建MyDate对象，并测试。
代码实现，效果如图所示：
开发提示：
- 闰年：
  - 普通年（不能被100整除的年份）能被4整除的为闰年。（如2004年就是闰年,1999年不是闰年）；
  - 世纪年（能被100整除的年份）能被400整除的是闰年。(如2000年是闰年，1900年不是闰年)；

public class MyDate { private int year; private int month; private int day; public MyDate() { } public MyDate(int year, int month, int day) { this.year = year; this.month = month; this.day = day; } public int getYear() { return year; } public void setYear(int year) { this.year = year; } public int getMonth() { return month; } public void setMonth(int month) { this.month = month; } public int getDay() { return day; } public void setDay(int day) { this.day = day; } public void showDate() { System.out.println("日期" + year + "年" + month + "月" + day + "日"); } public boolean isLeapYear() { return year % 4 == 0 && year % 100 != 0 || year % 400 == 0; } }

public class Test03 { public static void main(String[] args) { MyDate my = new MyDate(2019,5,13); my.showDate(); boolean flag = my.isLeapYear(); System.out.println(my.getYear()+ (flag?"是闰年":"不是闰年")); } }

第四题：语法练习

语法与技能：
- 类（属性、构造器、方法）、对象、this
定义一个扑克Card类
- 属性：
  - 花色
  - 点数
- 构造方法：
  - 满参构造方法
- 成员方法：
  - showCard方法：打印牌面信息
定义测试类，创建Card对象，调用showCard方法
代码实现，效果如图所示：

public class Card { private String hua; private String dian; public Card(String hua, String dian) { this.hua = hua; this.dian = dian; } public Card() { } public String getHua() { return hua; } public void setHua(String hua) { this.hua = hua; } public String getDian() { return dian; } public void setDian(String dian) { this.dian = dian; } public void showCard() { System.out.println(hua + dian); } }

public class Test03 { public static void main(String[] args) { Card c = new Card("黑桃", "A"); c.showCard(); } }

第五题：语法练习

案例：

1、声明矩形类com.atguigu.bean.Rectangle

（1）包含属性：长和宽，要求属性私有化

（2）给每一个属性提供get/set方法

（3）public double getArea()

（4）public double getPerimeter()

（5）提供getInfo()返回矩形对象的信息

例如：长：4，宽：2，面积：8，周长：12

2、测试类Test06，

（1）在main()方法中创建Rectangle对象，并用set方法为属性赋值

（2）调用get方法打印属性的值，调用getArea打印面积，调用getPerimeter打印周长

（3）再次调用set方法修改属性的值为原来属性值的两倍

（4）调用getInfo方法打印矩形信息

public class Rectangle { private double length; private double width; public void setLength(double chang){ length = chang; } public double getLength(){ return length; } public void setWidth(double kuan){ width = kuan; } public double getWidth(){ return width; } public double getArea(){ return length * width; } public double getPerimeter(){ return 2 * (length + width); } public String getInfo(){ return "长：" + length + "，宽：" + width + "，面积：" + getArea() + "，周长：" + getPerimeter(); } }

public class Test06 { public static void main(String[] args) { Rectangle r = new Rectangle(); r.setLength(2); r.setWidth(1); System.out.println("长：" + r.getLength()); System.out.println("宽：" + r.getWidth()); System.out.println("面积：" + r.getArea()); System.out.println("周长：" + r.getPerimeter()); r.setLength(r.getLength()*2); r.setWidth(r.getWidth()*2); System.out.println(r.getInfo()); } }