面向对象编程思想：“类”的引入
前面我们学习过数组，当需要多次遍历数组时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。
在对数组遍历的基础上继续增加需求，比如获取最值，数组逆转等，同样需要将这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？
在前面的学习过程中，我们知道“类”是可以存放方法的（虽然目前还不清楚如何去设计一个完整的类，但最起码知道，类中是可以存放多个方法的），比如：main方法，自定义的add方法，show方法，sop打印方法等。所以，我们就考虑使用“类”来封装多个方法，将来有需要再对数组做相关的操作时，不是直接去找自定义的方法，而是先找到封装了这个方法的类，然后使用这个类中的方法。这就是面向对象思想的编程方式。
从面相对象编程的角度考虑，类就是对多个方法的封装，当然，在类中除了方法，还有方法需要用到的一些变量等
- 功能的封装==>方法
- 多个方法和相关变量的封装==>类
当你在编程过程中，想实现一个功能，不是直接在main方法外边去定义方法，而是想到先去定义一个“类”的时候，你已经具备了面向对象的编程思想。
面向过程思想概述
之前如果想要完成一个需求，一般的步骤是：首先是搞清楚要做什么，然后再分析怎么做，最后我们再写代码实现
那么什么是面向过程开发呢？所谓的面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言
面向对象思想概述
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始改进，能不能把这些步骤和功能再进行封装，封装时根据不同的功能，进行不同的封装，功能类似的，或者有关联关系的封装在一起，这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。接下来我们看看面向对象到底是什么？
假设有一个任务：写一个功能完整的Java程序，然后把这个程序部署到测试环境中
仔细分析这个任务，发现需要完成这个任务的话，应该有两个动作：
- 写程序
- 部署到测试环境
如果按照面向过程的编程思想的话，应该编写两个函数，分别用来实现上面提到的两个功能，然后依次调用这些函数，当这两个函数执行完了之后，整个任务就完成了。
如果使用面向对象的思想编程的话，就把功能分解，交给不同的“对象”去完成。
对象：可以暂时理解成具有某些功能的一个综合体
例如，上面的任务中，涉及到了两个任务，写代码和部署程序，那么就去找哪个对象具有这样的功能，直接调用它们相应的方法就可以了
整个过程如下：
首先考虑谁会写代码，谁会部署程序，然后分别去找他们
找到对象1 --> 写代码 --> 完成
找到对象2 --> 部署程序 --> 完成
--> 整个任务完成
比如，有如下三个人，每个人都有自己的功能：使用伪码体现
张三{
Public void 部署程序(){
System.out.println("部署java程序");
}
}
李四{
Public void 写代码(){
System.out.println("写java代码")
}
}
小明{
Public void 玩游戏(){
System.out.println("玩游戏")
}
}
第三个人不具有想要使用的功能，所以不会用到
另外还有一个人，负责总指挥，调度每个人执行的先后顺序等
老板{
Public static void main(String[] args){
李四.写代码();
张三.部署程序 ();
...
}
}
从以上的概述可以得出这样的结论：
面向过程：强调的是过程，每个过程及实施都要自己一步一步去实施，考虑的事情比较多
面向对象：强调的是对象，需要某些功能的时候，去找具有这样功能的对象，然后由对象去调用功能
面向对象思想的特点
- 是一种更符合我们思想习惯的思想
- 可以将复杂的事情简单化，不必考虑执行的每一个细节，只从宏观上把握
- 将我们从执行者变成了指挥者
两种思想对比举例：
1.写Java程序：
- 面向过程：首先学习Java语法，然后编写Java程序，然后编译，运行
其中的每个细节都要自己去实施
- 面向对象：知道张三会写Java程序，去找张三，让张三写程序，把结果交给我
只需要找人去干活，然后等待结果即可
2.组装电脑：
- 面向过程：先要卖到各种硬件，然后自己动手组装，才能得到一台完整的电脑
- 面向对象：知道李四会组装电脑，找到李四，让李四组装一台电脑交给我
3.吃饭：
- 面向过程：买菜，洗菜，切菜，做菜，开吃
- 面向对象：找餐厅，找服务员点菜，做好菜交给我，开吃
类和对象的含义
前面说过：
对象：可以暂时理解成具有某些功能的一个综合体
这里详细介绍一下，在面向对象程序设计中，到底什么是对象，什么是类
- 对象：就是一个具体的事物，它有自己的属性和行为
比如：一只狗，它有属性：颜色，体重，品种，它有行为：跑，叫，看家等等
比如：一个手机，它有属性：颜色，价格，品牌等，它有行为：打电话，发短信等
比如：笔记本电脑，它有属性：品牌，价格，内存大小，它有行为：开机，关机，播放音乐，可以打字等等
- 类：同一种事物的抽象，将它们共同的属性和行为抽象出来，就是类
比如前面说的狗，可以抽象出来一个犬类，手机，可以抽象出一个手机类，在代码中就是用关键字class定义类
类与对象关系
在现实世界中，如何表示一个事物呢？或者说如何描述一个事物？应该从两个方面描述
- 属性 就是该种事物的静态信息，特点
- 行为 就是该种事物能够做什么，动作
举例：现实世界中如何描述单车这种事物？
属性：
颜色，轮子尺寸，车身高度...
行为：
骑行，拐弯，刹车...
举例：现实世界中是如何描述学生这种事物？
属性：
姓名，年龄，性别，家庭住址...
行为：
学习，写作业，吃饭...
以上的描述都是针对一类事物，并不是针对某个特定的个体，也就是说，以上的描述都是抽象的描述，而不是具体的某个个体。特定的个体在属性上一般来说都不相同
我们学习编程语言，就是为了模拟现实世界的事物的，换句话说，就是模拟如何描述一类事物的。Java语言中最基本的单位是：类，前面也介绍过，所谓的类，就是对一类事物共同的属性和行为的抽象
那现实世界里的事物和Java中的类是如何对应起来的呢？
|
现实世界中的事物 |
Java的类 |
|
属性 --> |
成员变量 |
|
行为 --> |
成员方法 |
在Java中，类有成员变量来对这一类事物的属性进行描述；有成员方法对这一类事物的行为进行模拟。
对象：就是一个具体的事物，它有自己的属性和行为，事物是一个抽象的概念，而对象是具体的个体
由于类属于是抽象的概念，所以，通常都是使用类去创建对象，然后再使用这个对象的属性或者方法，这种利用类创建对象的过程，称为“实例化”过程
总结一下面向对象的编程过程：实际上就是不断的编写各种“类”，然后利用类去创建对象，再使用对象，指挥对象完成功能
下图是面向对象开发的软件在逻辑上的组成结构，实际上就是各种类（成员变量+成员方法）
小结：
类：是一组相关的变量和方法的集合，是一个抽象的概念。
对象：是类实例化创建出来的，是“类”这个概念的具体表现形式
举例：
- 学生：是一个类，它是一个抽象的概念，有学号，姓名，年龄等属性；有学习，写作业等行为的都属于学生，不是指的某一个个体
- 张三：是学生类的一个具体对象，他是一个学生，具有学生的属性和行为
举例：
- 汽车：是一个类，它是一个抽象的概念，应该说能利用汽油，柴油等燃料产生动力，有轮子，有车牌，能在公路上行驶的都叫汽车
- 楼下的宝马：是汽车的一个具体对象，它拥有汽车的属性和行为：车牌，行驶
类的定义
从前面的介绍中了解到，Java中的类就是对现实世界中事物的模拟，它们的对应关系是：
|
现实世界中的事物 |
Java的类--》对象 |
|
属性 --> |
成员变量 |
|
行为 --> |
成员方法 |
在Java中，定义类其实就是定义类的成员(包含成员变量和成员方法)
类定义的举例：
定义一个学生类，来模拟现实世界中的学生这类事物
//学生类，现实世界中“学生”也是一个抽象概念，它是：所有的学生都有的共同点
//在Java中定义类，就是将这些共同点用class类模拟出来
class Student {
//姓名
String name;
//年龄
int age;
//地址
String address;
//所有学生都有“学习”这样的行为，在类中就是定义学习这样的方法
public void study() {
System.out.println("学习");
}
//吃饭的方法
public void eat() {
System.out.println("吃饭");
}
//睡觉的方法
public void sleep() {
System.out.println("睡觉");
}
}
类定义举例：
//手机类
//现实世界中，“手机”是一个抽象概念，
//在Java中模拟手机这个事物的话，就可以定义一个类，这个类拥有手机的属性和行为
class Phone {
//品牌
String brand;
//价格
int price;
//颜色
String color;
//打电话的方法
public void call(String name) {
System.out.println("给"+name+"打电话");
}
//发短信的方法
public void sendMessage() {
System.out.println("发短信");
}
//玩游戏的方法
public void playGame() {
System.out.println("玩游戏");
}
}
学生类的使用
- 如何定义一个类
模拟现实世界中事物的属性和行为，定义变量和方法
- 如何使用一个类
- 创建对象：
类名 对象名 = new 类名(); //目前就这一种使用格式，以后再详解其他方式
- 使用对象的变量或者方法：
对象名.成员变量
对象名.成员方法
//定义学生类
class Student {
//姓名
String name; //成员变量是有默认值的，引用数据类型，默认为null
//年龄
int age; //0
//地址
String address; //null
//学习
public void study() {
System.out.println("学习");
}
//吃饭
public void eat() {
System.out.println("吃饭");
}
//睡觉
public void sleep() {
System.out.println("睡觉");
}
}
//定义测试类，这个类主要是用来存放main方法，让JVM执行，不是用来创建对象用的
class StudentDemo {
public static void main(String[] args) {
//类名 对象名 = new 类名();
Student s = new Student();
//输出成员变量值
//System.out.println(s.name);
//System.out.println(s.age);
//System.out.println(s.address);
//改进写法
System.out.println(s.name+"---"+s.age+"---"+s.address);
//给成员变量赋值
s.name = "张三";
s.age = 27;
s.address = "北京";
//赋值后的输出
System.out.println(s.name+"---"+s.age+"---"+s.address);
//调用方法
s.study();
s.eat();
s.sleep();
}
}
实例：自定义手机类，并在测试类中测试其中的变量和方法
class Phone {
//品牌
String brand;
//价格
int price;
//颜色
String color;
//打电话的方法
public void call(String name) {
System.out.println("给"+name+"打电话");
}
//发短信的方法
public void sendMessage() {
System.out.println("发短信");
}
//玩游戏的方法
public void playGame() {
System.out.println("玩游戏");
}
}
class PhoneDemo {
public static void main(String[] args) {
//创建手机对象
//类名 对象名 = new 类名();
Phone p = new Phone();
//直接输出成员变量值
System.out.println(p.brand+"---"+p.price+"---"+p.color);
//给成员变量赋值
p.brand = "华为";
p.price = 100;
p.color = "灰色";
//再次输出
System.out.println(p.brand+"---"+p.price+"---"+p.color);
//调用方法
p.call("佟湘玉");
p.sendMessage();
p.playGame();
}
}
1个Phone对象的内存图及初始化过程
一个Phone对象的基本初始化过程
首先明确内存中的几块区域：
栈：即方法栈，方法调用的两个名词：压栈-push，弹栈-pop，局部变量在这里
堆：new出来的东西存放在这里
方法区：类的描述信息（成员变量，成员方法）
中间包含一段区域叫静态区，包含：静态变量，静态方法
Phone p = new Phone();
这条语句的执行过程：
加载Phone.class文件进内存
在栈内存为p开辟空间
在堆内存为对象开辟空间
把对象的实例变量进行默认初始化（）
把对象的实例变量进行显示初始化（在类定义中赋的值，String name = "tom";）
通过构造方法给对象的实例变量赋值（会覆盖显式初始化的值）（关于构造方法以后介绍）
对象初始化完毕，把对象地址赋值给p变量
对引用变量进行赋值
2个对象的内存图
方法的共用
实例方法存在于方法区，实例方法也是共享的，会被多个此类的实例所共享，堆中的对象实际上持有的是实例方法的引用，并不是每个对象都拷贝一份到自己的内存空间
3个对象的内存图
其中有两个引用指向同一个对象
实例变量和局部变量
定义：
实例变量：属于类的实例对象，没有static修饰的，目前接触到的成员变量都是实例变量
局部变量：属于方法的变量，只在方法内有效
区别：
在类中的位置不同
实例变量 在类中，并且在方法外定义
局部变量 方法内或者方法声明上（形参）定义
在内存中的位置不同
实例变量 堆内存（属于对象）
局部变量 栈内（属于方法）
生命周期不同
实例变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
实例变量 有默认的初始化值（0/false/null）
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
举例：验证局部变量的作用范围和必须初始化才能使用
/*
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
*/
class Variable {
//成员变量
//int num = 10;
int num; //成员变量有默认值0/false/null
public void show() {
//int num2 = 20; //局部变量
//可能尚未初始化变量num2
//int num2; //没有默认值，只能先赋值，之后才能使用
int num2 = 20;
System.out.println(num2);
//方法内使用的变量采用就近原则：方法内没有，就去找成员变量
System.out.println(num);
}
}
class VariableDemo {
public static void main(String[] args) {
Varialbe v = new Varialbe();
System.out.println(v.num); //访问成员变量
v.show();
}
}
形式参数问题
- 基本类型作为形式参数：传值，实际上就是把实参的值拷贝一份给形参，形参不论怎么改动，都不会影响到实参的值
- 引用类型作为形式参数：传递的是实参所指向的实例对象或者数组，即：传递的是实参的引用（地址值），形参和实参具有相同的引用，所以，形参对引用的改动能立即从实参上看到
/*
形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
*/
//形式参数是基本类型
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
//形式参数是引用类型
//先自定义一个类，有一个实例方法show
class Student {
public void show() {
System.out.println("学习");
}
}
class StudentDemo {
//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里需要的是该类的对象。
public void method(Student s) {
//调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
s.show();
}
}
class ArgsTest {
public static void main(String[] args) {
//形式参数是基本类型的调用
Demo d = new Demo();
int result = d.sum(10,20);
System.out.println("result:"+result);
System.out.println("--------------");
//形式参数是引用类型的调用
//需求：我要调用StudentDemo类中的method()方法
StudentDemo sd = new StudentDemo();
//创建学生对象
Student s = new Student();
sd.method(s); //把s的地址给到了这里
}
}
匿名对象
匿名对象：就是没有名字的对象，是对象的一种简化表示形式
匿名对象的两种使用情况
- 对象调用方法仅仅一次的时候，多次调用的时候，不适合用匿名对象
- 作为实际参数传递可以使用匿名对象
/*
匿名对象：就是没有名字的对象。
匿名对象的应用场景：
A:调用方法，仅仅只调用一次的时候。
注意：调用多次的时候，不适合。
这种匿名调用有什么好处吗?
有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递
*/
class Student {
public void show() {
System.out.println("我爱学习");
}
}
class StudentDemo {
public void method(Student s) {
s.show();
}
}
class NoNameDemo {
public static void main(String[] args) {
//带名字的调用
Student s = new Student();
s.show();
s.show();
System.out.println("--------------");
//匿名对象
//new Student();
//匿名对象调用方法
new Student().show();
new Student().show(); //这里其实是重新创建了一个新的对象
System.out.println("--------------");
//匿名对象作为实际参数传递
StudentDemo sd = new StudentDemo();
//Student ss = new Student();
//sd.method(ss); //这里的s是一个实际参数
//匿名对象
sd.method(new Student());
//再来一个，两个都是匿名对象
new StudentDemo().method(new Student());
}
}
封装概述
封装概述
封装是面向对象编程的三个重要特征之一，其余两个是多态和继承。
封装指的是隐藏对象的属性和实现细节，不允许外部直接访问对象的内部信息，而是通过该类提供的方法来实现对内部信息的访问。
封装是对现实世界的模拟，在现实世界中，对象的状态信息都被隐藏在对象的内部，外界无法直接操作和访问，例如一个人的年龄，是逐年增长的，假如暴露给外界的话，有可能会被外界修改。
对一个类或者对象的良好封装，可以达到以下的效果：
好处：
- 隐藏实现细节，
- 让使用者只能通过事先预定的方法来访问数据，从而可以在这个方法内加入逻辑控制，限制对成员变量的不合理访问
- 可以进行数据检查，从而有利于保证对象信息的完整性
- 便于修改，提高代码的可维护性
为了实现良好的封装，需要从以下两个方面来考虑
- 把对象的实例变量和实现细节隐藏起来，不允许外界直接访问
- 把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作
先看一个封装的例子：
使用一个关键字private来修饰成员变量，外界就不能对它直接访问了，想要使用它的话，就必须提供公开的方法来对它进行访问，在这个方法中，就可以加入一些逻辑判断了，例如：
/*
定义一个学生类：
成员变量：name，age
成员方法：show()方法
我们在使用这个案例的过程中，发现了一个问题：
通过对象去给成员变量赋值，可以赋值一些非法的数据。
这是不合理的。
应该是这个样子的：在赋值之前，先对数据进行判断。
判断到底在哪里做比较合适呢?
StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。
所以，这个判断应该定义在Student类中。
而我们在成员变量的位置可不可以进行数据判断呢?
是不可以的，因为做数据校验，必须要依靠一些逻辑语句。
逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法来对数据进行校验。
按照我们前面的分析，我们给出了一个方法进行校验。
但是呢，它偏偏不调用方法来赋值，还是直接赋值了，
这样我们的方法就没有起到作用。
我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。
怎么去强制要求不能直接使用成员变量呢?
针对这种情况，Java就提供了一个关键字 private
private:私有的。可以修饰成员变量和成员方法。
注意：被private修饰的成员只能在本类中访问。
其实我讲到现在讲解的是一个封装的思想。
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
*/
class Student {
//姓名
String name;
//年龄
private int age;
//写一个方法对数据进行校验
/*
返回值类型：void
参数列表：int a
*/
//age变量是私有的变量，在外界不能直接访问，但是类内部的方法却可以访问
//在外界通过访问这个公共方法，间接的访问到了私有的成员变量
//并且在方法内部还可以加入逻辑判断
public void setAge(int a) {
if(a < 0 || age > 150) {
System.out.println("年龄值非法");
}else {
age = a;
}
}
//show()方法,显示所有成员变量值，show()方法是公有的，所以能被外界直接访问
//由于show()方法是在类中定义的，所以本类中的所有变量都是可以被它访问的
//这样达到了间接访问的效果
public void show() {
System.out.println("姓名："+name);
System.out.println("年龄："+age);
}
}
class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
s.show();//默认值
System.out.println("--------------");
//给成员变量赋值
s.name = "林青霞";
//s.age = 27;
s.setAge(27);
s.show();
System.out.println("--------------");
//给age赋值
//s.age = -27; //这个数据是不合理的
//通过方法给值
s.setAge(-27);
s.show();
System.out.println("--------------");
}
}
一旦将成员变量定义成private的，就不能直接访问了，比如：
Student s = new Student();
System.out.println(s.age);//error
private关键字
private关键字：
- 是一个权限修饰符。
- 可以修饰成员(成员变量和成员方法)
- 被private修饰的成员只能本类中才能访问。
private最常见的应用：
- 把成员变量用private修饰
- 提供对应的getXxx()/setXxx()方法，这样在类的外部就可以通过公有的方法对这些私有变量进行访问了
一个标准的使用案例
class Demo {
//int num = 10;
//用private修饰，只能在类中进行访问
private int num = 10;
public void show() {
System.out.println(num);
}
//私有方法，只能在类中进行调用
private void method() {
System.out.println("method");
}
public void function() {
method();
}
}
class PrivateDemo {
public static void main(String[] args) {
Demo d = new Demo();
//不能访问私有的成员变量
//System.out.println(d.num);
d.show();
//不能访问私有的成员方法
//d.method();
d.function();
}
}
正常Student类测试
/*
封装和private的应用：
A:把成员变量用private修饰
B:提供对应的getXxx()和setXxx()方法
*/
//定义学生类
class Student {
//私有的成员变量
private String name;
private int age;
public String getName() {
return name;
}
//公有的访问方法
//姓名设置值
public void setName(String n) {
name = n;
}
//年龄获取值
public int getAge() {
return age;
}
//年龄赋值
public void setAge(int a) {
age = a;
}
}
//测试类
class StudentTest {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//使用成员变量
//错误：被私有修饰了的变量，外界（类的外部）不能直接访问了
//System.out.println(s.name+"---"+s.age);
//OK，通过公有方法可以访问私有的成员变量
System.out.println(s.getName()+"---"+s.getAge());
//给成员变量赋值
//s.name = "林青霞";
//s.age = 27;
//通过公有方法给赋值
s.setName("林青霞");
s.setAge(27);
System.out.println(s.getName() +"---"+s.getAge());
}
}
面向对象练习
定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试类Test，进行测试。
/*
变量什么时候定义为成员变量：
如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。
变量到底定义在哪里好呢?
变量的范围是越小越好。因为能及时的被回收。
*/
//方式1
/*
class Demo {
public int sum() {
int a = 10;
int b = 20;
int c = a + b;
return c;
}
}
*/
//方式1满足了我们的要求，但是不好。
//因为参与操作的数据现在是固定的。
//方式2
/*
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
*/
//方式2可以满足我们的要求，但是呢我们学习过来面向对象的思想。
//我就再想，a，b可不可以定义为成员变量呢?
//如果可以，我们再改进一版
class Demo {
int a;
int b;
public int sum() {
return a + b;
}
}
//虽然这种方式可以，并且好像是符合了面向对象的思想。
//但是不好。
//因为我们曾经说过：类是一组相关的属性和行为的集合。
//并且类是通过事物转换过来的
//而类中的成员变量就是事物的属性
//属性是用来描述事物的
//同理：成员变量其实是用来描述类的。
//测试类
class Test {
public static void main(String[] args) {
//创建对象
//方式1测试
/*
Demo d = new Demo();
System.out.println(d.sum());
*/
//方式2测试
/*
Demo d = new Demo();
int a = 10;
int b = 20;
System.out.println(d.sum(a,b));
*/
//方式3测试
Demo d = new Demo();
d.a = 10;
d.b = 20;
System.out.println(d.sum());
}
}
//以上做法没有体现封装，
//正规的做法是私有的成员变量，公有的getxxx/setxxx方法
//调用求和方法之前，用setxxx方法对成员变量进行赋值
定义一个长方形类rectangle,定义求周长girth和面积area的方法，然后定义一个测试类Test2，进行测试。
/*
长方形的类：
成员变量：
长，宽
成员方法：
求周长：(长+宽)*2;
求面积：长*宽
注意：
import必须出现在所有的class前面。
*/
import java.util.Scanner;
class ChangFangXing {
//长方形的长
private int length;
//长方形的宽
private int width;
public ChangFangXing(){}
//仅仅提供setXxx()即可
public void setLength(int length) {
this.length = length;
}
public void setWidth(int width) {
this.width = width;
}
//求周长
public int getZhouChang() {
return (length + width) * 2;
}
//求面积
public int getArea() {
return length * width;
}
}
class Test2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入长方形的长：");
int length = sc.nextInt();
System.out.println("请输入长方形的宽：");
int width = sc.nextInt();
//创建对象
ChangFangXing cfx = new ChangFangXing();
//先给成员变量赋值
cfx.setLength(length);
cfx.setWidth(width);
System.out.println("周长是："+cfx.getZhouChang());
System.out.println("面积是："+cfx.getArea());
}
}