第7章面向对象编程_基础部分
2022/9/17 1:17:14
本文主要是介绍第7章面向对象编程_基础部分，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
1.类与对象
1.0 介绍
张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫猫。
- 单独的定义变量解决
不利于数据的管理(你把一只猫的信息拆解)
- 使用数组解决
(1)数据类型体现不出来
(2) 只能通过[下标]获取信息，造成变量名字和内容的对应关系不明确
(3) 不能体现猫的行为
public class Object01 {
//编写一个main方法
public static void main(String[] args) {
/*
张老太养了两只猫猫:一只名字叫小白,今年3岁,白色。
还有一只叫小花,今年100岁,花色。请编写一个程序，当用户输入小猫的名字时，
就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，
则显示 张老太没有这只猫猫。
*/
//单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)
//第1只猫信息
// String cat1Name = "小白";
// int cat1Age = 3;
// String cat1Color = "白色";
// //第2只猫信息
// String cat2Name = "小花";
// int cat2Age = 100;
// String cat2Color = "花色";
//数组 ===>(1)数据类型体现不出来(2) 只能通过[下标]获取信息，造成变量名字和内容
// 的对应关系不明确(3) 不能体现猫的行为
//第1只猫信息
// String[] cat1 = {"小白", "3", "白色"};
// String[] cat2 = {"小花", "100", "花色"};
//使用OOP面向对象解决
//实例化一只猫[创建一只猫对象]
//老韩解读
//1. new Cat() 创建一只猫(猫对象)
//2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1
//3. cat1 就是一个对象
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
cat1.weight = 10;
//创建了第二只猫，并赋给 cat2
//cat2 也是一个对象(猫对象)
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 100;
cat2.color = "花色";
cat2.weight = 20;
//怎么访问对象的属性呢
System.out.println("第1只猫信息" + cat1.name
+ " " + cat1.age + " " + cat1.color + " " + cat1.weight);
System.out.println("第2只猫信息" + cat2.name
+ " " + cat2.age + " " + cat2.color + " " + cat2.weight);
}
}
//使用面向对象的方式来解决养猫问题
//
//定义一个猫类 Cat -> 自定义的数据类型
class Cat {
//属性/成员变量
String name; //名字
int age; //年龄
String color; //颜色
//double weight; //体重
//行为
}
1.1 类与对象的关系示意图
类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型.
对象是具体的，实际的，代表一个具体事物, 即是实例.
类是对象的模板，对象是类的一个个体，对应一个实例
1.2对象在内存中存在形式(重要的)必须搞清楚
Java 内存的结构分析
栈： 一般存放基本数据类型(局部变量)
堆： 存放对象(Cat cat , 数组等)
方法区：常量池(常量，比如字符串)， 类加载信息
Person p = new Person(); p.name = “jack”; p.age = 10
-
先加载 Person 类信息(属性和方法信息, 只会加载一次)
-
在堆中分配空间, 进行默认初始化(看规则)
-
把地址赋给 p , p 就指向对象
-
进行指定初始化， 比如 p.name =”jack” p.age = 10
1.3属性/成员变量/字段
-
从概念或叫法上看： 成员变量 = 属性 = field(字段) （即 成员变量是用来表示属性的，统一叫 属性)
-
属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类 的 int age 就是属性
1.3.1 注意事项和细节说明
- 属性的定义语法同变量，示例：
访问修饰符 属性类型 属性名;
有四种访问修饰符 public, proctected, 默认, private ,后面会详细介绍。
-
属性的定义类型可以为任意类型，包含基本类型或引用类型
-
属性如果不赋值，有默认值，规则和数组一致。具体说:
int 0，short 0, byte 0, long 0, float 0.0,double 0.0，
char \u0000， boolean false，String null
public class PropertiesDetail {
//编写一个main方法
public static void main(String[] args) {
//创建Person对象
//p1 是对象名(对象引用)
//new Person() 创建的对象空间(数据) 才是真正的对象
Person p1 = new Person();
//对象的属性默认值，遵守数组规则:
//int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
System.out.println("\n当前这个人的信息");
System.out.println("age=" + p1.age + " name="
+ p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
}
}
class Person {
//四个属性
int age;
String name;
double sal;
boolean isPass;
}
1.4 如何创建对象
- 先声明再创建
Cat cat ; //声明对象 cat
cat = new Cat(); //创建
- 直接创建
Cat cat = new Cat();
1.5 如何访问属性
基本语法
对象名.属性名;
案例演示赋值和输出
cat.name ;
cat.age;
cat.color;
类和对象的内存分配机制(重要)
2.成员方法
2.1基本介绍
在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄，姓名..),我们人类还有一 些行为比如:可以说话、跑步..,通过学习，还可以做算术题。这时就要用成员方法才能完成。
public class Method01 {
//编写一个main方法
public static void main(String[] args) {
//方法使用
//1. 方法写好后，如果不去调用(使用)，不会输出
//2. 先创建对象 ,然后调用方法即可
Person p1 = new Person();
p1.speak(); //调用方法
p1.cal01(); //调用cal01方法
p1.cal02(5); //调用cal02方法，同时给n = 5
p1.cal02(10); //调用cal02方法，同时给n = 10
//调用getSum方法，同时num1=10, num2=20
//把 方法 getSum 返回的值，赋给 变量 returnRes
int returnRes = p1.getSum(10, 20);
System.out.println("getSum方法返回的值=" + returnRes);
}
}
class Person {
String name;
int age;
//方法(成员方法)
//添加speak 成员方法,输出 “我是一个好人”
//老韩解读
//1. public 表示方法是公开
//2. void ： 表示方法没有返回值
//3. speak() : speak是方法名， () 形参列表
//4. {} 方法体，可以写我们要执行的代码
//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
public void speak() {
System.out.println("我是一个好人");
}
//添加cal01 成员方法,可以计算从 1+..+1000的结果
public void cal01() {
//循环完成
int res = 0;
for(int i = 1; i <= 1000; i++) {
res += i;
}
System.out.println("cal01方法 计算结果=" + res);
}
//添加cal02 成员方法,该方法可以接收一个数n，计算从 1+..+n 的结果
//老韩解读
//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
public void cal02(int n) {
//循环完成
int res = 0;
for(int i = 1; i <= n; i++) {
res += i;
}
System.out.println("cal02方法 计算结果=" + res);
}
//添加getSum成员方法,可以计算两个数的和
//老韩解读
//1. public 表示方法是公开的
//2. int :表示方法执行后，返回一个 int 值
//3. getSum 方法名
//4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
//5. return res; 表示把 res 的值， 返回
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;
}
}
2.2方法的调用机制原理：(重要!-示意图!!!)
2.3为什么需要成员方法
提高代码的复用性
可以将实现的细节封装起来，然后供其他用户来调用即可
看一个需求：
请遍历一个数组 , 输出数组的各个元素值。
解决思路 1，传统的方法，就是使用单个 for 循环，将数组输出，大家看看问题是什么？
解决思路 2: 定义一个类 MyTools ,然后写一个成员方法，调用方法实现,看看效果又如何。
2.4成员方法的定义
访问修饰符 返回数据类型 方法名（形参列表..） {//方法体
语句；
return 返回值;
}
形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)
返回数据类型：表示成员方法输出, void 表示没有返回值
方法主体：表示为了实现某一功能代码块
return 语句不是必须的。
2.5注意事项和使用细节
-
访问修饰符 (作用是控制 方法使用的范围) ;如果不写默认访问，[有四种: public, protected, 默认, private],
-
返回数据类型:
-
一个方法最多有一个返回值 [思考，如何返回多个结果 返回数组 ]
-
返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
-
如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的
值类型一致或兼容
- 如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;
-
-
方法名
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如 得到两个数的和 getSum, 开发中按照规范
public class MethodDetail {
public static void main(String[] args) {
AA a = new AA();
int[] res = a.getSumAndSub(1, 4);
System.out.println("和=" + res[0]);
System.out.println("差=" + res[1]);
//细节: 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
byte b1 = 1;
byte b2 = 2;
a.getSumAndSub(b1, b2);//byte -> int
//a.getSumAndSub(1.1, 1.8);//double ->int(×)
//细节: 实参和形参的类型要一致或兼容、个数、顺序必须一致
//a.getSumAndSub(100);//× 个数不一致
a.f3("tom", 10); //ok
//a.f3(100, "jack"); // 实际参数和形式参数顺序不对
}
}
class AA {
//细节: 方法不能嵌套定义
public void f4() {
//错误
// public void f5() {
// }
}
public void f3(String str, int n) {
}
//1. 一个方法最多有一个返回值 [思考，如何返回多个结果 返回数组 ]
public int[] getSumAndSub(int n1, int n2) {
int[] resArr = new int[2]; //
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
//2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
// 具体看 getSumAndSub
//
//3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
// 而且要求返回值类型必须和return的值类型一致或兼容
public double f1() {
double d1 = 1.1 * 3;
int n = 100;
return n; // int ->double
//return d1; //ok? double -> int
}
//如果方法是void，则方法体中可以没有return语句，或者 只写 return ;
//老韩提示：在实际工作中，我们的方法都是为了完成某个功能，所以方法名要有一定含义
//，最好是见名知意
public void f2() {
System.out.println("hello1");
System.out.println("hello1");
System.out.println("hello1");
int n = 10;
//return ;
}
}
public class MethodDetail02 {
//编写一个main方法
public static void main(String[] args) {
A a = new A();
//a.sayOk();
a.m1();
}
}
class A {
//同一个类中的方法调用：直接调用即可
//
public void print(int n) {
System.out.println("print()方法被调用 n=" + n);
}
public void sayOk() { //sayOk调用 print(直接调用即可)
print(10);
System.out.println("继续执行sayOK()~~~");
}
//跨类中的方法A类调用B类方法：需要通过对象名调用
public void m1() {
//创建B对象, 然后在调用方法即可
System.out.println("m1() 方法被调用");
B b = new B();
b.hi();
System.out.println("m1() 继续执行:)");
}
}
class B {
public void hi() {
System.out.println("B类中的 hi()被执行");
}
}
2.6类定义的完善
2.7成员方法传参机制(非常非常重要)
方法的传参机制对我们今后的编程非常重要，一定要搞的清清楚楚明明白白.
2.7.1基本数据类型的传参机制
public class MethodParameter01 {
//编写一个main方法
public static void main(String[] args) {
int a = 10;
int b = 20;
//创建AA对象 名字 obj
AA obj = new AA();
obj.swap(a, b); //调用swap
System.out.println("main方法 a=" + a + " b=" + b);//a=10 b=20
}
}
class AA {
public void swap(int a,int b){
System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
//完成了 a 和 b的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
}
}
2.7.2 引用数据类型的传参机制
引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！
看一个案例 MethodParameter02.java
B 类中编写一个方法 test100，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？会变化；
B 类中编写一个方法 test200，可以接收一个 Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变化？会变化。
public class MethodParameter02 {
//编写一个main方法
public static void main(String[] args) {
//测试
B b = new B();
// int[] arr = {1, 2, 3};
// b.test100(arr);//调用方法
// System.out.println(" main的 arr数组 ");
// //遍历数组
// for(int i = 0; i < arr.length; i++) {
// System.out.print(arr[i] + "\t");
// }
// System.out.println();
//测试
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test200(p);
//测试题, 如果 test200 执行的是 p = null ,下面的结果是 10
//测试题, 如果 test200 执行的是 p = new Person();..., 下面输出的是10
System.out.println("main 的p.age=" + p.age);//10000
}
}
class Person {
String name;
int age;
}
class B {
public void test200(Person p) {
//p.age = 10000; //修改对象属性
//思考
p = new Person();
p.name = "tom";
p.age = 99;
//思考
//p = null;
}
//B类中编写一个方法test100，
//可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化
public void test100(int[] arr) {
arr[0] = 200;//修改元素
//遍历数组
System.out.println(" test100的 arr数组 ");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
}
}
图解
2.8成员方法返回类型是引用类型应用实例
public class MethodExercise02 {
//编写一个main方法
public static void main(String[] args) {
Person p = new Person();
p.name = "milan";
p.age = 100;
//创建tools
MyTools tools = new MyTools();
Person p2 = tools.copyPerson(p);
//到此 p 和 p2是Person对象，但是是两个独立的对象，属性相同
System.out.println("p的属性 age=" + p.age + " 名字=" + p.name);
System.out.println("p2的属性 age=" + p2.age + " 名字=" + p2.name);
//这里老师提示： 可以同 对象比较看看是否为同一个对象
System.out.println(p == p2);//false
}
}
class Person {
String name;
int age;
}
class MyTools {
//编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象，
//注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
//
//编写方法的思路
//1. 方法的返回类型 Person
//2. 方法的名字 copyPerson
//3. 方法的形参 (Person p)
//4. 方法体, 创建一个新对象，并复制属性，返回即可
public Person copyPerson(Person p) {
//创建一个新的对象
Person p2 = new Person();
p2.name = p.name; //把原来对象的名字赋给p2.name
p2.age = p.age; //把原来对象的年龄赋给p2.age
return p2;
}
}
3.方法递归调用(非常非常重要，比较难)
3.1基本介绍
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
3.2递归举例
public class Recursion01 {
//编写一个main方法
public static void main(String[] args) {
T t1 = new T();
t1.test(4);//输出什么？ n=2 n=3 n=4
int res = t1.factorial(5);
System.out.println("5的阶乘 res =" + res);
}
}
class T {
//分析
public void test(int n) {
if (n > 2) {
test(n - 1);
}
System.out.println("n=" + n);
}
//factorial 阶乘
public int factorial(int n) {
if (n == 1) {
return 1;
} else {
return factorial(n - 1) * n;
}
}
}
3.3递归重要规则
4.斐波那契数列
请使用递归的方式求出斐波那契数列1,1,2,3.5,8,13.….给你一个整数n，求出它的值是多。
/**
* 斐波那契数列
*/
public class FibonacciSeq {
public static void main(String[] args) {
Fibonacci f = new Fibonacci();
int res = f.fibonacciSeq(-2);
if (res != -1) {
System.out.println("斐波那契数列数列结果=" + res);
}
}
}
class Fibonacci {
public int fibonacciSeq(int num){
/*
思路分析
1. 当 n = 1 斐波那契数 是 1
2. 当 n = 2 斐波那契数 是 1
3. 当 n >= 3 斐波那契数 是前两个数的和
4. 这里就是一个递归的思路:要求当前的数需要用到前面的数
*/
if (num >=1) {
if (num == 1 || num == 2) {
return 1;
} else {
return fibonacciSeq(num-1) + fibonacciSeq(num-2);
}
} else {
System.out.println("请输入正数");
return -1;//需要返回语句
}
}
}
5.猴子吃桃子问题
有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个!以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时(即还没吃)发现只有1个桃子了。问题:最初共多少个桃子?
public class MonkeyEatPeachDemo {
public static void main(String[] args) {
MonkeyEatPeach m = new MonkeyEatPeach();
int day = 1;
int res = m.count_Peach_Num(day);
if (res != -1) {
System.out.println("res=" + res);
}
}
}
class MonkeyEatPeach {
/**
* 思路分析
* 逆推
* 1. day = 10 时 有 1 个桃子
* 2. day = 9 时 有 (day10 + 1) * 2 = 4
* 3. day = 8 时 有 (day9 + 1) * 2 = 10
* 4. 规律就是 前一天的桃子 = (后一天的桃子 + 1) *2
* 5. 递归
*/
public int count_Peach_Num(int day) {
if (day == 10) {
return 1;
} else if (day>=1 && day<=9) {
return 2 * (count_Peach_Num(day + 1) + 1);//规则很重要
} else {
System.out.println("时间范围在1-10天");
return -1;
}
}
}
6.迷宫问题
public class MiGong {
public static void main(String[] args) {
//思路
//1.先创建迷宫，用二维数组来表示
//int[][] map = new int[8][8]
//2.数组元素值中：0表示可以走，1表示障碍物
//设置常量，改变便于改变迷宫大小
final int ROW = 9;
final int COL = 8;
int[][] map = new int[ROW][COL];
// System.out.println(map.length);//9
//将迷宫的第一行和最后一行设置为1，表示障碍物，走不通
for (int i=0; i<COL; i++) {
map[0][i] = 1;
map[ROW-1][i] = 1;
}
//将迷宫的第一列和最后一列设置为1，表示障碍物，走不通
for (int i=0; i<ROW; i++) {
map[i][0] = 1;
map[i][COL-1] = 1;
}
//单独设置两个障碍物
map[3][1] = 1;
map[3][2] = 1;
System.out.println("====原始迷宫===");
//当前地图情况
for (int i=0; i<map.length; i++) {
for (int j=0; j<map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
M m = new M();
m.findWay(map, 1,1);
System.out.println("===寻找出路之后===");
for (int i=0; i<map.length; i++) {
for (int j=0; j<map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
}
}
class M {
//编写一个方法来寻找路径
//思路
//1.findWay()方法就是专门用来寻找迷宫的路径
//2.如果找到就返回true,否则就返回false
//3.map就是二维数组，即表示迷宫
//4.i j 就是老鼠在的位置，初试的位置在(1,1)
//5.由于是递归的找路，先规定map数组中各个值的含义
// 0表示可以走，1表示障碍物，2表示可以走完的路，3表示走过的，但走不通（回溯）
//6.设置倒数第二行和倒数第二列的位置为终点，表示结束，否则继续找
//7.先确定找路的策略：上 ->下 ->左 -> 右
public boolean findWay(int[][] map, int i, int j){
// map[7][6] == 2
if ( map[map.length-2][map[i].length-2] == 2 ) {//说明已经找到
return true;
} else {
if (map[i][j] == 0) {//表示当前这个位置可以走
//先假定找到终点
map[i][j] = 2;
//使用查找策略:上 下 左 右 （找不到终点）
//改为 下 右 上 左
if (findWay(map, i-1, j)) {
return true;
} else if (findWay(map, i+1, j)) {
return true;
} else if (findWay(map, i, j-1)) {
return true;
} else if (findWay(map, i, j+1)) {
return true;
} else {
map[i][j] = 3;//到死角了
return false;
}
} else { //map[i][j] == 1 2 3
return false;//不可以走了
}
}
}
}
先确定找路的策略：上 ->下 ->左 -> 右
7.汉诺塔
public class HanoiTower {
public static void main(String[] args) {
Tower t = new Tower();
t.move(5, 'A', 'B', 'C');
}
}
class Tower {
//编写方法
//num 表示移动的盘数， a b c分别表示A塔 B塔 C塔
public void move(int num, char a, char b, char c) {
if (num == 1) {
System.out.println(a + "->" + c);
} else {
//如果有多个盘，可以看成两个 , 最下面的一个和上面的所有盘(num-1)
//(1)先移动上面所有的盘到 b, 借助 c
move(num-1, a,c,b);
//(2)把最下面的这个盘移动到c
System.out.println(a + "->" + c);
//(3)再把b塔的所有盘，游动到c,借助a
move(num-1,b,a,c);
}
}
}
8.方法重载(OverLoad)
8.1基本介绍
java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！
比如：System.out.println(); out 是 PrintStream 类型
8.2重载的好处
-
减轻了起名的麻烦
-
减轻了记名的麻烦
public class OverLoad01 {
//编写一个main方法
public static void main(String[] args) {
// System.out.println(100);
// System.out.println("hello,world");
// System.out.println('h');
// System.out.println(1.1);
// System.out.println(true);
//
MyCalculator mc = new MyCalculator();
System.out.println(mc.calculate(1, 2));
System.out.println(mc.calculate(1.1, 2));
System.out.println(mc.calculate(1, 2.1));
}
}
class MyCalculator {
//下面的四个 calculate方法构成了重载
//两个整数的和
public int calculate(int n1, int n2) {
System.out.println("calculate(int n1, int n2) 被调用");
return n1 + n2;
}
//没有构成方法重载, 仍然是错误的，因为是方法的重复定义
// public void calculate(int n1, int n2) {
// System.out.println("calculate(int n1, int n2) 被调用");
// int res = n1 + n2;
// }
//看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
// public int calculate(int a1, int a2) {
// System.out.println("calculate(int n1, int n2) 被调用");
// return a1 + a2;
// }
//一个整数，一个double的和
public double calculate(int n1, double n2) {
return n1 + n2;
}
//一个double ,一个Int和
public double calculate(double n1, int n2) {
System.out.println("calculate(double n1, int n2) 被调用..");
return n1 + n2;
}
//三个int的和
public int calculate(int n1, int n2,int n3) {
return n1 + n2 + n2;
}
}
8.3注意事项
9.可变参数
9.1基本概念
java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。 就可以通过可变参数实现。
9.2基本语法
访问修饰符 返回类型 方法名(数据类型... 形参名) {
}
public class VarParameter01 {
//编写一个main方法
public static void main(String[] args) {
HspMethod m = new HspMethod();
System.out.println(m.sum(1, 5, 100)); //106
System.out.println(m.sum(1,19)); //20
}
}
class HspMethod {
//可以计算 2个数的和，3个数的和 ， 4. 5， 。。
//可以使用方法重载
// public int sum(int n1, int n2) {//2个数的和
// return n1 + n2;
// }
// public int sum(int n1, int n2, int n3) {//3个数的和
// return n1 + n2 + n3;
// }
// public int sum(int n1, int n2, int n3, int n4) {//4个数的和
// return n1 + n2 + n3 + n4;
// }
//.....
//上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
//老韩解读
//1. int... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
public int sum(int... nums) {
//System.out.println("接收的参数个数=" + nums.length);
int res = 0;
for(int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
}
9.3注意事项
public class VarParameterDetail {
//编写一个main方法
public static void main(String[] args) {
//细节: 可变参数的实参可以为数组
int[] arr = {1, 2, 3};
T t1 = new T();
t1.f1(arr);
}
}
class T {
public void f1(int... nums) {
System.out.println("长度=" + nums.length);
}
//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public void f2(String str, double... nums) {
}
//细节: 一个形参列表中只能出现一个可变参数
//下面的写法是错的.
// public void f3(int... nums1, double... nums2) {
// }
}
10.作用域
10.1基本使用
public class VarScope {
//编写一个main方法
public static void main(String[] args) {
}
}
class Cat {
//全局变量：也就是属性，作用域为整个类体 Cat类：cry eat 等方法使用属性
//属性在定义时，可以直接赋值
int age = 10; //指定的值是 10
//全局变量(属性)可以不赋值，直接使用，因为有默认值，
double weight; //默认值是0.0
public void hi() {
//局部变量必须赋值后，才能使用，因为没有默认值
int num = 1;
String address = "北京的猫";
System.out.println("num=" + num);
System.out.println("address=" + address);
System.out.println("weight=" + weight);//属性
}
public void cry() {
//1. 局部变量一般是指在成员方法中定义的变量
//2. n 和 name 就是局部变量
//3. n 和 name的作用域在 cry方法中
int n = 10;
String name = "jack";
System.out.println("在cry中使用属性 age=" + age);
}
public void eat() {
System.out.println("在eat中使用属性 age=" + age);
//System.out.println("在eat中使用 cry的变量 name=" + name);//错误
}
}
10.22注意事项
public class VarScopeDetail {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();
/*
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量，生命周期较短，伴随着它的代码块的执行而创建，
伴随着代码块的结束而销毁。即在一次方法调用过程中
*/
//p1.say();//当执行say方法时，say方法的局部变量比如name,会创建，当say执行完毕后
//name局部变量就销毁,但是属性(全局变量)仍然可以使用
//
T t1 = new T();
t1.test(); //第1种跨类访问对象属性的方式
t1.test2(p1);//第2种跨类访问对象属性的方式
}
}
class T {
//全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
public void test() {
Person p1 = new Person();
System.out.println(p1.name);//jack
}
public void test2(Person p) {
System.out.println(p.name);//jack
}
}
class Person {
//细节: 属性可以加修饰符(public protected private..)
// 局部变量不能加修饰符
public int age = 20;
String name = "jack";
public void say() {
//细节 属性和局部变量可以重名，访问时遵循就近原则
String name = "king";
System.out.println("say() name=" + name);
}
public void hi() {
String address = "北京";
//String address = "上海";//错误,重复定义变量
String name = "yt";//可以
}
}
11.构造方法/构造器
我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。
11.1基本语法
[修饰符] 方法名(形参列表){
方法体;
}
构造器的修饰符可以默认， 也可以是 public protected private
构造器没有返回值
方法名 和类名字必须一样
参数列表 和 成员方法一样的规则
构造器的调用, 由系统完成
11.2基本介绍
构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
方法名和类名相同
没有返回值
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
public class Constructor01 {
//编写一个main方法
public static void main(String[] args) {
//当我们new 一个对象时，直接通过构造器指定名字和年龄
Person p1 = new Person("smith", 80);
System.out.println("p1的信息如下");
System.out.println("p1对象name=" + p1.name);//smith
System.out.println("p1对象age=" + p1.age);//80
}
}
//在创建人类的对象时，就直接指定这个对象的年龄和姓名
//
class Person {
String name;
int age;
//构造器
//
//1. 构造器没有返回值, 也不能写void
//2. 构造器的名称和类Person一样
//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
public Person(String pName, int pAge) {
System.out.println("构造器被调用~~ 完成对象的属性初始化");
name = pName;
age = pAge;
}
}
11.3注意事项和使用细节
public class ConstructorDetail {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person("king", 40);//第1个构造器
Person p2 = new Person("tom");//第2个构造器
Dog dog1 = new Dog();//使用的是默认的无参构造器
}
}
class Dog {
//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
//使用javap指令 反编译看看
/*
默认构造器
Dog() {
}
*/
//一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
//除非显式的定义一下,即: Dog(){} 写 (这点很重要)
//
public Dog(String dName) {
//...
}
Dog() { //显式的定义一下 无参构造器
}
}
class Person {
String name;
int age;//默认0
//第1个构造器
public Person(String pName, int pAge) {
name = pName;
age = pAge;
}
//第2个构造器, 只指定人名，不需要指定年龄
public Person(String pName) {
name = pName;
}
}
12.对象创建的流程分析
13.this 关键字
13.1介绍
问题:构造方法的输入参数名不是非常的好，如果能够将dName改成 name就好了，但是我们会发现按照变量的作用域原则,name的值就是null,怎么解决->this
public class This01 {
//编写一个main方法
public static void main(String[] args) {
Dog dog1 = new Dog("大壮", 3);
System.out.println("dog1的hashcode=" + dog1.hashCode());
//dog1调用了 info()方法
dog1.info();
System.out.println("============");
Dog dog2 = new Dog("大黄", 2);
System.out.println("dog2的hashcode=" + dog2.hashCode());
dog2.info();
}
}
class Dog{ //类
String name;
int age;
// public Dog(String dName, int dAge){//构造器
// name = dName;
// age = dAge;
// }
//如果我们构造器的形参，能够直接写成属性名，就更好了
//但是出现了一个问题，根据变量的作用域原则
//构造器的name 是局部变量，而不是属性
//构造器的age 是局部变量，而不是属性
//==> 引出this关键字来解决
public Dog(String name, int age){//构造器
//this.name 就是当前对象的属性name
this.name = name;
//this.age 就是当前对象的属性age
this.age = age;
System.out.println("this.hashCode=" + this.hashCode());
}
public void info(){//成员方法,输出属性x信息
System.out.println("this.hashCode=" + this.hashCode());
System.out.println(name + "\t" + age + "\t");
}
}
什么是this 哪个对象调用，this就代表哪个对象
java虚拟机会给每个对象分配 this,代表当前对象。坦白的讲，要明白this不是件容易的事,我给大家打一个比方。[上帝创世界小故事]
13.2 this 的注意事项和使用细节
-
this 关键字可以用来访问本类的属性、方法、构造器
-
this 用于区分当前类的属性和局部变量
-
访问成员方法的语法：this.方法名(参数列表);
-
访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一 条语句)
-
this 不能在类定义的外部使用，只能在类定义的方法中使用。
public class ThisDetail {
//编写一个main方法
public static void main(String[] args) {
// T t1 = new T();
// t1.f2();
T t2 = new T();
t2.f3();
}
}
class T {
String name = "jack";
int num = 100;
/*
细节: 访问构造器语法：this(参数列表);
注意只能在构造器中使用(即只能在构造器中访问另外一个构造器)
注意： 访问构造器语法：this(参数列表); 必须放置第一条语句
*/
public T() {
//这里去访问 T(String name, int age) 构造器
this("jack", 100);
System.out.println("T() 构造器");
}
public T(String name, int age) {
System.out.println("T(String name, int age) 构造器");
}
//this关键字可以用来访问本类的属性
public void f3() {
String name = "smith";
//传统方式
System.out.println("name=" + name + " num=" + num);//smith 100
//也可以使用this访问属性
System.out.println("name=" + this.name + " num=" + this.num);//jack 100
}
//细节: 访问成员方法的语法：this.方法名(参数列表);
public void f1() {
System.out.println("f1() 方法..");
}
public void f2() {
System.out.println("f2() 方法..");
//调用本类的 f1
//第一种方式
f1();
//第二种方式
this.f1();
}
}
13.3 this练习
public class TestPerson {
public static void main(String[] args) {
Person p1 = new Person("jim",20);
// Person p2 = new Person("tom", 19);
Person p2 = new Person("jim", 20);
System.out.println(p1.compareTo(p2));
}
}
class Person {
String name;
int age;
// 构造器
Person (String name, int age){
this.name = name;
this.age = age;
}
//难点：Person类也可以作为参数传入，进而比较属性是否相同
public boolean compareTo(Person p){
// if (p.name == this.name && p.age==this.age) {
// return true;
// } else {
// return false;
// }
// 优化
return this.name.equals(p.name) && this.age == p.age;
}
}
这篇关于第7章面向对象编程_基础部分的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-12-26大厂数据结构与算法教程：入门级详解
- 2024-12-26大厂算法与数据结构教程：新手入门指南
- 2024-12-26Python编程入门指南
- 2024-12-26数据结构高级教程：新手入门及初级提升指南
- 2024-12-26并查集入门教程：从零开始学会并查集
- 2024-12-26大厂数据结构与算法入门指南
- 2024-12-26大厂算法与数据结构入门教程
- 2024-12-26二叉树入门教程：轻松掌握基础概念与操作
- 2024-12-26初学者指南：轻松掌握链表
- 2024-12-26平衡树入门教程：轻松理解与应用
