本文目录
十一、方法
- 在其他语言中可能被称为“函数”
- 方法就好像一个工厂
参数（原料）
返回值（产出物）
- 格式
修饰符 返回值类型 方法名称(参数类型 参数名称){
方法体
return 返回值;
}
- 解释
a. 修饰符：目前的固定写法，两个关键字，public static
b. 返回值类型：方法最终产生的数据是什么类型
c. 方法名称：自定义的名字，规则与变量一样
d. 参数类型：进入方法的数据是什么类型
e. 参数名称：进入方法的数据对应的变量名称
f. 方法体：需要执行的若干行代码
g. return：有两个作用，一是结束当前方法，二是带着后面的返回值交给调用处
h. 返回值：方法的最终数据结果
- 注意事项
a. 返回值类型必须和返回值对应
b. 若参数有多个，则使用逗号分隔
c. 若不需要参数，则小括号内可留空
d. 多个方法之间定义的前后顺序无所谓
e. 方法中不能嵌套定义方法
f. 方法定义后，不会执行，需要调用执行
- 代码示例
示例一：
public class Demo00_MethodDefine {
/*
* 定义方法三要素：返回值类型，方法名称，参数列表
*/
public static int sum(int a, int b) {
System.out.println("成功调用sum方法！");
int result = a + b;
return result;
}
public static void main(String[] args) {
}
}
示例二：键盘输入两个int数字，定义一个方法求出其中的最大值
import java.util.Scanner;
public class Demo02_MethodMax {
//键盘输入两个int数字，定义一个方法求出其中的最大值
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个int数字：");
int a = sc.nextInt();
System.out.println("请输入第二个int数字：");
int b = sc.nextInt();
//调用getMax方法
int max = getMax(a, b);
System.out.println("最大值为：" + max);
}
public static int getMax(int x, int y) {
if(x > y) {
return x;
}else {
return y;
}
}
}
- 单独调用
格式：
方法名称(参数值);
弊端：
无法使用方法的返回值
- 打印调用
// 格式
System.out.println(方法名称(参数值));
- 赋值调用
格式：
数据类型 变量名称 = 方法名称(参数值);
注意:
调用方法，并将返回值交给一个变量。
变量的数据类型必须和方法的返回值类型对应
- 图解：方法的调用流程
- 代码示例
public class Demo01_MethodInvoke {
public static void main(String[] args) {
//单独调用
sum(20,30);
//打印调用
System.out.println(sum(12, 20));
//赋值调用
int all = (sum(5, 4));
System.out.println(all);
}
}
- 格式
修饰符 void 方法名称(参数类型 参数名称){
方法体
return; //一般省略
}
- 注意
a. 返回值与参数没有必然联系，没有返回值不代表不能有参数
b. 不能return一个具体的返回值
c. 只能使用【单独调用】，不能使用【打印调用】或【赋值调用】
public class Demo03_MethodVoid {
public static void main(String[] args) {
//单独调用
helloHelloWorld();
System.out.println("======================");
helloHelloWorldCount(3);
System.out.println("======================");
}
/*
* 定义一个方法，用来固定10次输出
*
* 返回值类型：屏幕打印输出，没有结果数据需要还给调用处，无返回值
*/
public static void helloHelloWorld() {
for(int i = 0; i < 10; i++) {
System.out.println( i + " HelloWorld!");
}
return; // 最后一行return语句可以省略
return 100; // 错误写法！void就不能有具体的返回值
}
/*
* 定义一个方法，用来打印输出指定次数的helloworld
*
* 参数列表：需要知道到底是几次，所以需要一个int类型
*/
public static void helloHelloWorldCount(int count) {
for(int i = 0; i < count; i++) {
System.out.println( i + " HelloWorld!");
}
}
- 对比返回值的有无
a. 定义一个方法，用来【求出】数组元素的总和。（告诉我最终结果是多少）
b. 定义一个方法，用来【打印】数组元素的总和。你自己打印就得了，不用告诉我结果）
/*
* 对比两种情况：
*
* 1. 定义一个方法，用来【求出】数组元素的总和。（告诉我最终结果是多少）
* 2. 定义一个方法，用来【打印】数组元素的总和。（你自己打印就得了，不用告诉我结果）
*/
public class Demo04_VoidVsReturn {
public static void main(String[] args) {
int[] array = {56,-9,-63,45,65,89,24};
//赋值调用
System.out.println("sumA求出的总和为：" + sumA(array));
//单独调用
sumB(array);
}
/*
* 1. 定义一个方法，用来【求出】数组元素的总和。
*/
public static int sumA(int[] arr) {
int sum = 0;
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum; //sum中的数据就是最终结果
}
/*
* 2. 定义一个方法，用来【打印】数组元素的总和。
*/
public static void sumB(int[] arr) {
int sum = 0;
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println("sumB打印的总和:" + sum);
}
}
- 图解
- 代码示例
示例：遍历数组，是指对数组当中的每一个数据元素进行逐一、挨个儿处理。默认的遍历就是打印输出。
public class Demo05_PrintArray {
public static void main(String[] args) {
int[] array = {56,45,546,98,34,24,64,24,68};
//调用方法，传入参数数据（一个数组）
printArray(array);
}
//定义printArray方法,用来对数组进行遍历打印输出
public static void printArray(int[] arr) {
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public class Demo06_PrintArrayFormat {
public static void main(String[] args) {
int[] array = {10,20,30,40,50};
//调用
printArrayFormat(array);
}
/*
* 定义一个方法，进行数组遍历，但是要求使用指定格式
*
* 输出：[10,20,30,40,50]
*/
public static void printArrayFormat(int[] arr) {
/*
* println:通过写入行分隔符终止当前行
* print：只打印给定内容
*/
System.out.print("[");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
//判断是否打印结束
if(i == arr.length - 1) {
System.out.print("]");
}else {
System.out.print(",");
}
}
}
}
- 方法名称相同，但是参数列表不同
- 注意：
a. 参数个数不同：sum(int a, int b) sum(int a, int b，int c)
b. 参数的类型不同：sum(int a, int b) sum(int a, double b)
c. 参数的多类型顺序不同：sum(int a, double b) sum(double b，int a)
d. 不能根据返回值类型不同进行重载
e. 与参数名称无关：sum(int a, int b) sum(int x, int y)
- 代码示例 （当时没有敲这段代码，直接cv下来的）
public class MethodOverload {
public static void main(String[] args) {
// System.out.println(sumTwo(10, 20)); // 30
// System.out.println(sumThree(10, 20, 30)); // 60
// System.out.println(sumFour(10, 20, 30, 40)); // 100
System.out.println(sum(10, 20)); // 30
System.out.println(sum(10, 20, 30)); // 60
System.out.println(sum(10, 20, 30, 40)); // 100
// System.out.println(sum(10, 20, 30, 40, 50)); // 错误的写法！因为没有任何一种重载形式能对上
System.out.println("===============");
System.out.println(sum(10, 20)); // int
System.out.println(sum(10.5, 20.5)); // double
System.out.println("===============");
System.out.println(sum(2.5, 10)); // 先double后int
System.out.println(sum(10, 2.5)); // 先int后double
}
public static double sum(int a, double b) {
System.out.println("先int后double的方法执行！");
return a + b; // 注意！不同数据类型的数值相加，谁的范围大，结果就是谁
}
public static double sum(double a, int b) {
System.out.println("先double后int的方法执行！");
return a + b; // 注意！不同数据类型的数值相加，谁的范围大，结果就是谁
}
public static double sum(double a, double b) {
System.out.println("有2个double参数的方法执行！");
return a + b;
}
public static int sum(int a, int b) {
System.out.println("有2个int参数的方法执行！");
return a + b;
}
// 错误写法！与参数的名称无关
// public static int sum(int x, int y) {
// System.out.println("有2个int参数的方法执行！");
// return x + y;
// }
// 错误写法！重载与返回值无关！
// public static double sum(int a, int b) {
// System.out.println("有2个int参数的方法执行！");
// return a + b + 0.0;
// }
public static int sum(int a, int b, int c) {
System.out.println("有3个int参数的方法执行！");
return a + b + c;
}
public static int sum(int a, int b, int c, int d) {
System.out.println("有4个int参数的方法执行！");
return a + b + c + d;
}
}
- 什么叫做“参数传递”？
也就是在调用方法的时候，向方法内传入一些数据的动作。
- 分类
形式参数：
在【定义】方法的时候，写在小括号之内的参数。（被动接收数据的）
public static int sum(int a, int b) {...} //这里的a和b是在定义的时候写的，所以是形式参数。
实际参数：
在【调用】方法的时候，真正传入方法里的数据，叫做实际参数。（主动传入数据的）
int num = sum(10, 20）; //这里的10和20是在调用的时候传入方法的，所以它们是实际参数。
int x = 10;
int y = 20;
int result = sum(x,y); //这里的x和y也是在调用方法的时候传入的，所以也是实际参数。
- 参数传递的过程中，有两项规则：
规则1： 对于基本数据类型（以及String）来说，形参的操作【不会】影响实参。
规则2： 对于引用数据类型（除了String）来说，形参的操作【会】影响实参。
解释1
解释2
- 代码示例
示例一：基本类型传参
/*
* 对于基本数据类型（以及String）来说，形参的操作【不会】影响实参。
*/
public class Demo07_MethodParamBasic {
public static void main(String[] args) {
int a = 10, b = 20;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("======================");
change(a,b); //实参
System.out.println("======================");
System.out.println("a = " + a);
System.out.println("b = " + b);
}
//定义一个方法，用来将参数扩大10倍
public static void change(int x, int y) { //形参
x *= 10;
y *= 10;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
}
示例二：引用类型传参
/*
* 对于引用数据类型（除了String）来说，形参的操作【会】影响实参。
*/
public class Demo08_MethodParamRef {
public static void main(String[] args) {
int[] array = {10,20,30};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println("=============");
change(array);
System.out.println("=============");
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
}
public static void change(int[] arr) {
arr[0] *= 10;
arr[1] *= 10;
arr[2] *= 10;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
示例三：方法的参数类型
/*
* 方法的参数可以是什么类型？
* 1. 基本类型
* 2. 数组
* 3. 字符串
* 4. 自定义的类
*
* 结论：所有数据类型都可以作为方法的参数类型。
*/
public class Demo09_MethodParam {
public static void main(String[] args) {
method1 (100);
System.out.println("============");
int[] arr = { 10, 20, 30 };
method2(arr);
System.out.println("============");
method3 ("How do you do?");
System.out.println("============");
Demo10_Student xueSheng = new Demo10_Student("赵丽颖", 20);
method4 (xueSheng);
}
// 使用基本类型作为方法的参数，可以
public static void method1(int num) {
num += 20;
System.out.println(num); // 120
}
// 使用数组作为方法的参数，也可以
public static void method2(int[] array) {
System.out.println(array[0]); // 10
System.out.println(array[1]); // 20
System.out.println(array[2]); // 30
}
// 使用字符串作为方法的参数，也可以
public static void method3(String str) {
String result = str.replace("o", "*");
System.out.println(result); // H*w d* y*u d*?
}
// 使用自定义的类作为方法的参数，照样可以！
public static void method4(Demo10_Student stu) {
// 姓名：赵丽颖，年龄：20
System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
}
}
示例四：方法的返回值类型
// 先定义一个学生类
public class Demo10_Student {
private String name;
private int age;
public Demo10_Student() {
}
public Demo10_Student(String name, int age) {
this.name = name; // 马上会讲到
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/*
* 方法的返回值可以是什么类型？
*
* 1. 基本类型
* 2. 数组
* 3. 字符串
* 4. 自定义的类
*
* 所有数据类型都可以作为方法的返回值类型。
*/
public class Demo11_MethodReturn {
public static void main(String[] args) {
int result1 =method1 ();
System.out.println(result1); // 100
System.out.println("==================");
int[] result2 = method2 ();
System.out.println(result2[0]); // 10
System.out.println(result2[1]); // 20
System.out.println("==================");
String result3 = method3 ();
System.out.println(result3.replace("o", "*")); // H*w d* y*u d*?
System.out.println("==================");
Demo10_Student result4 = method4();
// 姓名：赵丽颖，年龄：20
System.out.println("姓名：" + result4.getName() + "，年龄：" + result4.getAge());
}
// 使用基本类型作为方法的返回值，可以
public static int method1() {
int num = 100;
return num;
}
// 使用数组类型作为方法的返回值，也可以
public static int[] method2() {
int[] array = { 10, 20 };
return array;
}
// 使用字符串作为方法的返回值，还可以
public static String method3() {
String str = "How do you do?";
return str;
}
// 使用自定义的类作为方法的返回值，仍然可以
public static Demo10_Student method4() {
Demo10_Student stu = new Demo10_Student("赵丽颖", 20);
return stu;
}
}
十二、POJO
-
面向过程思想：注重于每一个步骤怎么做，整体过程是怎样的，每个操作需要自己亲力亲为。
-
面向对象思想：但需要实现一个功能的时候，不看重具体过程和步骤是怎样的 ，而关心“谁能帮我做这件事”。
-
特征：封装性、继承性、多态性
-
代码示例
import java.util.Arrays;
public class Demo01_PrintArray {
public static void main(String[] args) {
//面向过程
int[] array = {10,32,65,98,45};
System.out.print("[");
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]);
if(i == array.length - 1) {
System.out.println("]");
}else {
System.out.print(", ");
}
}
System.out.println("====================");
//面向对象
System.out.println(Arrays.toString(array));
}
}
-
属性：事物的描述信息（是什么）
-
行为：事物的能力行动方案 （能做什么）
-
类：抽象的，由属性和行为组成，模拟现实事物（手机设计图）
-
对象：具体的，是类的实例化（真正的手机）
-
模拟现实事物的代码手段
-
包含：
成员变量（属性）：将变量位置直接定义在类中，在方法外
成员方法（行为）：将普通的方法去掉static关键字，即为成员方法
- 使用类：（引用类型，见“扫描器Scanner类”）
a. 导包（同一包下，可省略，否则使用 import）
b. 创建
c. 使用
- 根据类创建对象
a. 创建对象：
类名称 对象名 = new 类名称();
b. 创建变量：（见“扫描器Scanner类”）
数据类型 变量名称 = new 数据类型();
c. 使用对象：
对象名.成员变量名
若没有对成员变量赋值，则输出的是堆中给的默认值
d. 使用对象当中的成员方法
对象名.成员方法名(参数);
e.总结：
想用谁就 . "点"谁
- 代码示例
示例一：
/*
* 先创建一个学生类
*
* 成员变量（属性）：
* String name; //姓名
* int age; //年龄
*
* 成员方法（行为）：
* public void eat() {...}
* public void sleep() {...}
* public void study() {...}
*/
public class Demo02_Student {
//成员变量
String name;
int age;
//成员方法
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void study() {
System.out.println("学习");
}
}
public class Demo02_UseStudent {
public static void main(String[] args) {
//创建学生对象stu1
Demo02_Student stu1 = new Demo02_Student();
//未赋值之前，使用学生对象stu1
System.out.println(stu1.name);
System.out.println(stu1.age);
System.out.println("=======================");
//赋值之后，使用学生对象stu1
stu1.name = "张三";
stu1.age = 20;
System.out.println(stu1.name);
System.out.println(stu1.age);
System.out.println("=======================");
//将对象中的成员变量交给names变量
String names = stu1.name;
System.out.println(names);
System.out.println("=======================");
//使用对象中的成员方法
stu1.eat();
stu1.sleep();
stu1.study();
}
}
- 一个对象
注：方法都要进栈处理
-
两个对象
-
同一个对象
- 定义的位置不同【重点记忆】
局部变量： 定义在方法内部（成员方法的参数也是局部变量）
成员变量： 直接定义在类中，在方法外
- 内存中位置不同
局部变量： 在栈内存中，Stack
成员变量： 在堆内存中，Heap
- 生命周期不同
局部变量： 随方法的进栈而出现，随方法的出栈而消失
成员变量： 随着对象被创建而出现，随着对象被JVM回收而消失
- 默认值不同【重点记忆】
局部变量： 无默认值，必须被赋值才能使用
成员变量： 有默认值，后可被更改
- 代码示例
/*
* 定义一个类，模拟手机
*
* 组成：
* 属性：品牌、价格、颜色
* —— 成员变量：
* String brand;
* double price;
* String color;
*
* 行为：打电话、发短信
* —— 成员方法：
* public void call(String who) {}
* public void sengMessage() {}
*/
public class Demo03_Phone {
String brand;
double price;
String color;
public void call(String who) {
System.out.println("给" + who + "打电话");
}
public void sengMessage() {
System.out.println("群发短信！");
}
}
public class Demo03_UsePhone {
public static void main(String[] args) {
//使用类创建对象one
Demo03_Phone one = new Demo03_Phone();
System.out.println("创建对象one");
//使用对象（默认）
System.out.println(one.brand);
System.out.println(one.price);
System.out.println(one.color);
System.out.println("=====================");
//使用对象（赋值）
one.brand = "华为";
one.price = 5000;
one.color = "深空灰";
System.out.println(one.brand);
System.out.println(one.price);
System.out.println(one.color);
System.out.println("=====================");
//使用成员方法
one.call("李四");
one.sengMessage();
System.out.println("==========================================");
//快速选中光标所在以下的同一个单词：alt + shift + R
//使用类创建对象two
Demo03_Phone two = new Demo03_Phone();
System.out.println("创建对象two");
//使用对象（默认）
System.out.println(two.brand);
System.out.println(two.price);
System.out.println(two.color);
System.out.println("=====================");
//使用对象（赋值）
two.brand = "苹果";
two.price = 6000.0;
two.color = "深邃蓝";
System.out.println(two.brand);
System.out.println(two.price);
System.out.println(two.color);
System.out.println("=====================");
//使用成员方法
two.call("jack");
two.sengMessage();
System.out.println("==========================================");
/*
* 使用类创建对象three
*
* 将one中存储的地址值赋给three一份
*/
Demo03_Phone three = one;
System.out.println("创建对象three");
//使用对象（one中的对象）
System.out.println(three.brand);
System.out.println(three.price);
System.out.println(three.color);
System.out.println("=====================");
//使用对象（赋新值）
three.brand = "荣耀";
three.price = 4000.0;
three.color = "深邃蓝";
System.out.println(three.brand);
System.out.println(three.price);
System.out.println(three.color);
System.out.println("=====================");
//使用成员方法
three.call("王五");
three.sengMessage();
System.out.println("==========================================");
}
}
-
作用： 确保数据安全、合理
-
范围： 本类范围之外无法直接使用
-
间接访问：为private成员变量编写一对Setter Getter方法
Getter方法： 返回值类型且与成员变量一致
Setter方法： 返回值类型必须为void，参数必须和成员变量相同
注意：
a. 对于除boolean以外的其他数据类型，Getter必须叫getXxxx,Setter必须叫setXxxx
b. 对于基本数据类型当中的boolean，那么setXxxx规则不变，而getXxxx需要写成isXxxx形式
- 代码示例
public class Demo04_Person {
String name;
private int age;
public void show() {
System.out.println("我是" + name + ",今年" + age + "岁！");
}
//定义成员方法设置成员变量，Setter方法
public void setAge(int num) { //返回值类型必须为void，参数必须和成员变量相同
//监测数据是否合理
if (num <= 0 || num >= 200) {
System.out.println("数据错误！");
}else {
age = num;
}
}
//定义成员方法获取成员变量，Getter方法
public int getAge() { //返回值的类型要与成员变量的一致！
return age;
}
}
public class Demo04_UsePerson {
public static void main(String[] args) {
Demo04_Person person = new Demo04_Person();
//创建对象
person.name = "张三";
//调用方法
person.setAge(20);
//调用方法
person.show();
}
}
-
作用： 解决成员变量和局部变量的重名问题
-
用法： this.成员变量名
-
扩展： 通过谁调用的方法，谁就是this
-
代码示例
public class Person {
String name; // 我自己的名字
public void sayHello(String name) { // 对方的名字
System.out.println(name + "，你好。我是" + this.name + "。");
}
}
- 定义：
专门用来创建对象的方法。即通过new关键字创建对象时，其实就是在调用构造方法。
- 格式
//定义构造方法
public 构造方法名(参数类型 参数名称) {
方法体
return; //通常不写
}
//调用构造方法
new 类名称()
- 注意：
a. 构造方法不能写返回值类型，包括void
b. 构造方法名必须和所在的类名称完全相同，包括大小写
c. 可重载
d. 若没有自定义构造方法，则默认赠送一个；若自定义了至少一个，则不再赠送
package day06;
public class Demo06_Notice {
//类中没有自定义任何构造方法，则编译器会自动赠送一个无参、无操作的构造方法，形如：public Demo06_Notice() { }
}
package day06;
public class Demo06_NoticeConstructor {
public static void main(String[] args) {
//系统赠送的
Demo06_NoticeConstructor notice = new Demo06_NoticeConstructor();
}
}
//什么都不输出
- 构造方法的重载（overload）
重载： 方法相同，参数列表不同
好处： 定义一个无参数的构造方法，可以直接new对象；定义一个重载的全参数的构造方法，可以在new对象的同时方便对成员变量直接赋值。
- 代码示例
public class Demo05_Constructor {
private String name;
private int age;
//无参数的构造方法
public Demo05_Constructor() { //没有参数就不写
System.out.println("无参数的构造方法执行！");
}
//重载1：有参数的构造方法
public Demo05_Constructor(int num) { //没有参数就不写
System.out.println("重载一个参数的构造方法执行！" + num);
}
//重载2
public Demo05_Constructor(String name,int age) {
this.name = name;
this.age = age;
System.out.println("重载两个参数的构造方法执行！" + "\n" + "姓名：" + name + " 年纪：" + age);
}
//为private成员变量编写一对Setter Getter方法
//菜单栏的Source中可以自动构造
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Demo05_UseConstructor {
public static void main(String[] args) {
//过new关键字创建对象时，其实就是在调用构造方法。
Demo05_Constructor con = new Demo05_Constructor();
//调用有参构造方法
Demo05_Constructor cons = new Demo05_Constructor(18); //18传给num
System.out.println("========================");
//通过setter方法进行赋值
Demo05_Constructor one = new Demo05_Constructor();
one.setName("张杰");
one.setAge(36);
System.out.println("名字: " + one.getName() + " , 年纪：" + one.getAge());
System.out.println("========================");
//直接在new的时候通过构造方法给成员变量赋值
Demo05_Constructor two = new Demo05_Constructor("龙井",56);
//改变成员变量的值
two.setAge(60);
System.out.println("姓名：" + two.getName() + " 年纪：" + two.getAge());
}
}
a. 所有成员变量都要使用privete关键字私有化
b. 为每个成员变量编写一对Getter Setter方法
c. 编写一个无参构造方法
d. 编写一个全参构造方法
代码示例
示例一：
public class Demo07_PoJo {
private String name;
private int age;
//一对Getter Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//无参构造
public Demo07_PoJo() {
}
//全参构造
public Demo07_PoJo(String name, int num) {
this.name = name; //区分
age = num;
}
}
public class Demo07_UsePoJo {
public static void main(String[] args) {
//默认无参构造
Demo07_PoJo pojo1 = new Demo07_PoJo();
pojo1.setName("gao");
pojo1.setAge(21);
System.out.println("姓名：" + pojo1.getName() + " 年龄：" + pojo1.getAge());
//全参构造
Demo07_PoJo pojo2 = new Demo07_PoJo("yang",19);
System.out.println("姓名：" + pojo2.getName() + " 年龄：" + pojo2.getAge());
//通过setter方法更改
pojo2.setAge(20);
System.out.println("姓名：" + pojo2.getName() + " 年龄：" + pojo2.getAge());
}
}
示例二：
/*
* 定义一个类代表“人”，含有姓名和年龄，且具有打招呼的功能。
*
* 根据类创建两个对象且赋值。
* 让两个对象分别和对方打招呼。
*/
public class Demo08_Human {
private String name;
private int age;
//getter setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//无参构造
public Demo08_Human() {
}
//全参构造
public Demo08_Human(String name,int age) {
this.name = name;
this.age = age;
}
//成员方法
public void sayHello(String other) {
System.out.println(other + "您好！我是" + this.name + ",我今年" + this.age + "岁。");
}
}
/*
* 定义一个类代表“人”，含有姓名和年龄，且具有打招呼的功能。
*
* 根据类创建两个对象且赋值。
* 让两个对象分别和对方打招呼。
*/
public class Demo08_UseHuman {
public static void main(String[] args) {
//默认构造
Demo08_Human hu1 = new Demo08_Human();
hu1.setName("张三");
hu1.setAge(43);
//有参构造
Demo08_Human hu2 = new Demo08_Human("李四",32);
//让hu1先和hu2打招呼
hu1.sayHello(hu2.getName());
//让hu2跟hu1打招呼
hu2.sayHello(hu1.getName());
}
}
615
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
