1. 类与对象
1.1 类与对象的引入
有两只猫,一只叫小白,今年 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", "白色"}; //第 2 只猫信息 String[] cat2 = {"小花", "100", "花色"};
1.2 类与对象的关系
类是自定义的数据类型,对象是类的一个具体实例,两者的关系可以类比 int 类型与具体值:
猫类Cat:自定义的数据类型 ➡ 猫对象(具体一只猫)
int:Java提供的数据类型 ➡ 100, 200,300
从类到对象,目前有几种说法:(1)创建一个对象;(2)实例化一 个对象;(3)把类实例化
对于 1.1 中的问题,可以用面向对象(OOP)的方式解决:
public class Test {
public static void main(String[] args) {
//第1只猫
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
cat1.weight = 10;
//第2只猫
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 100;
cat2.color = "花色";
cat2.weight = 20;
//访问对象的属性
System.out.println("第1只猫信息:" + cat1.name
+ "\t" + cat1.age + "\t" + cat1.color + "\t" + cat1.weight);
System.out.println("第2只猫信息:" + cat2.name
+ "\t" + cat2.age + "\t" + cat2.color + "\t" + cat2.weight);
}
}
class Cat {
String name; //名字
int age; //年龄
String color; //颜色
double weight; //体重
}
1.3 属性 / 成员变量 / 字段
从概念或叫法上看: 成员变量 = 属性 = field(字段)。
-
属性可以是基本数据类型,也可以是引用类型(对象,数组)。
class Car { String name; double price; String color; String[] master;//属性是引用类型(数组) }
-
属性的定义语法同变量,但多了“访问修饰符”。示例:private int num;
访问修饰符的作用:控制属性的访问范围。
4种访问修饰符: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 Test { public static void main(String[] args) { Person p1 = new Person(); System.out.println("age = " + p1.age) ; System.out.println("name = " + p1.name); System.out.println("salary = " + p1.salary); System.out.println("isPass = " + p1.isPass); } } class Person { int age; String name; double salary; boolean isPass; }
输出结果:
age = 0 name = null salary = 0.0 isPass = false
1.4 创建对象
-
先声明再创建
Cat cat ; cat = new Cat();
声明对象以后,栈中的 对象名 / 对象的引用 的内容为 null,创建对象后,堆中有了对象的空间,对象名的内容才是对象的地址。
-
直接创建
Cat cat = new Cat();
1.5 访问属性
访问属性的方式:对象名.属性名,如:cat.name,cat.age,cat.color。
1.6 类和对象的内存分配机制
Java 内存的结构分析:
- 栈:一般存放基本数据类型(局部变量)。
- 堆:存放对象、数组等。
- 方法区:常量池(常量,比如字符串),类加载信息。
上图注解:
① 先加载 Cat 类信息(属性和方法信息, 只会加载一次)。
② 在堆中分配空间,进行默认初始化(看1.3中的规则)。再把地址赋给 cat , cat 就指向对象。
③ 进行指定初始化,如:cat.name = “小白”。
【例】
2. 成员方法
2.1 方法的定义和使用
在某些情况下,我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外(年龄,姓名……),还有一些行为比如:说话、跑步,这时就要用成员方法。现在要求对Person 类完善。
public class Test {
public static void main(String[] args) {
Person p1 = new Person();
p1.speak();
p1.cal01();
p1.cal02(5);
p1.cal02(10);
int returnRes = p1.getSum(10, 20);
System.out.println("getSum 方法返回的值=" + returnRes);
}
}
class Person {
String name;
int age;
public void speak() {
System.out.println("我是一个好人");
}
public void cal01() {
int res = 0;
for(int i = 1; i <= 1000; i++) {
res += i;
}
System.out.println("cal01 方法 计算结果=" + res);
}
public void cal02(int n) {
int res = 0;
for(int i = 1; i <= n; i++) {
res += i;
}
System.out.println("cal02 方法 计算结果=" + res);
}
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;
}
}
2.2 方法的调用机制
2.3 方法的优势
(1) 提高代码的复用性。
(2) 将实现的细节封装起来,其他用户直接调用即可。
看一个需求:
遍历一个数组 , 输出数组的各个元素值(共3次)。
public class Test {
public static void main(String[] args) {
int[][] map = {{0,0,1},{1,1,1},{1,1,3}};
MyTools tool = new MyTools();
tool.printArr(map);
tool.printArr(map);
tool.printArr(map);
}
}
class MyTools {//工具类
public void printArr(int[][] map) {
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] + "\t");
}
System.out.println();
}
}
}
2.3 方法的使用细节
-
方法的访问修饰符作用是控制方法的使用范围,如果不写,就是“默认访问”,共有 4 种:public, protected, 默认, private。
-
一个方法最多有一个返回值,若想带回多个数据,可返回一个数组。
public class Test { 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]); } } class AA { public int[] getSumAndSub(int n1, int n2) {//返回值是数组 int[] resArr = new int[2]; resArr[0] = n1 + n2; resArr[1] = n1 - n2; return resArr; } }
-
参数和返回值可以为任意类型,包含基本类型和引用类型(如:数组,对象)。
-
如果方法要求有返回值,则方法体中必须有 return ,而且要求返回值类型必须和 return 值类型一致或兼容(涉及自动类型转换的问题)。
public double f1() { double d1 = 1.1; int n = 100; return n; //正确 int ➡ double //return d1; //错误 double ➡ int }
-
如果方法是 void,则方法体中可以没有 return 语句,或者 只写 return。
-
方法定义时的参数称为形参;方法调用时的传入参数称为实参,实参和形参的类型要一致或兼容,个数、顺序必须致。
-
方法不能嵌套定义。
public void f4() { //错误 public void f5() { } }
-
同一个类中的方法调用:不用事先创建对象,直接调用即可。被调方法和主调方法前后顺序无妨。
public class Test { public static void main(String[] args) { A a = new A(); a.sayOk(); } } class A { public void print(int n) { System.out.println("print()方法被调用 n=" + n); } public void sayOk() {//被调用的方法在sayOk方法前后均可 print(10); } }
-
跨类中的方法 A 类调用 B 类方法:需要先创建 B 的对象,再调用其方法,A、B类的前后顺序无妨。(实际上,主类调用其他自定义类也是一样的操作)
class A { public void m1() { B b = new B(); b.hi(); } } class B { public void hi() { System.out.println("B 类中的 hi()被执行"); } }
-
特别说明一下:跨类的方法调用与方法的访问修饰符相关,后面详讲。
2.4 方法的传参机制
2.4.1 基本数据类型传参
基本数据类型,传递的是值(值拷贝),形参的改变不影响实参。
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
AA obj = new AA();
//仅仅是将main方法中的值拷贝一份给了swap方法
//swap方法调用完成后,相关的变量等信息就出栈,带不到main方法中来
obj.swap(a, b);
System.out.println("main方法中: "+a + "\t" + b);//a=10 b=20
}
}
class AA {
public void swap(int a,int b){
System.out.println("交换前: " + a + "\t" + b);//a=10 b=20
int tmp = a;
a = b;
b = tmp;
System.out.println("交换前: " + a + "\t" + b);//a=20 b=10
}
}
2.4.2 引用类型传参
引用类型,传递的是地址,可以通过形参影响实参。
(1)数组传参
public class Test {
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();
}
}
class B {
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();
}
}
分析:
输出结果:
test100的arr数组:200 2 3
mian的arr数组:200 2 3
(2)对象传参
public class Test {
public static void main(String[] args) {
B b = new B();
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test200(p);
System.out.println("main的p.age="+p.age);
}
}
class Person {
String name;
int age;
}
class B {
public void test200(Person p) {
p = 10000;
}
}
分析:
输出结果:
main的p.age=10000
【例1】
public class Test {
public static void main(String[] args) {
B b = new B();
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test200(p);
//函数返回后,test200方法的相关内容出栈,包括其中的对象p
//且该对象p不能被带回mian函数,main函数后续使用的p仍是原对象
System.out.println("main的p.age="+p.age);
}
}
class Person {
String name;
int age;
}
class B {
public void test200(Person p) {//传过来一个对象的地址,使p的内容为该对象的地址
p = null;//但又马上置为空
}
}
输出结果:
main的p.age=10
【例2】
```java
public class Test {
public static void main(String[] args) {
B b = new B();
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test200(p);
//函数返回后,test200方法的相关内容出栈,包括其中的对象p
//且该对象p不能被带回mian函数,main函数后续使用的p仍是原对象
System.out.println("main的p.age="+p.age);
}
}
class Person {
String name;
int age;
}
class B {
public void test200(Person p) {//传过来一个对象的地址,使p的内容为该对象的地址
p = new Person();//但又马上置为另一个新对象的地址
p.name = "tom";
p.age = 99;
}
}
输出结果:
main的p.age=10
【例3】编写一个方法 copyPerson,可以复制一个 Person 对象,返回复制的对象。 注意要求得到新对象和原来的对象是两个独立的对象,只是他们的属性相同。
public class Test {
public static void main(String[] args) {
B b = new B();
Person p = new Person();
p.name = "jack";
p.age = 10;
Person np = b.copyPerson(p);
System.out.println("p.name="+p.name+" p.age="+p.age);
System.out.println("np.name="+np.name+" np.age="+np.age);
System.out.println(p == np);//判断两者是否为同一个对象
}
}
class Person {
String name;
int age;
}
class B {
public Person copyPerson(Person p) {
Person np = new Person();
np.name = p.name;
np.age = p.age;
return np;
}
}
2.5 方法的递归调用
调用方法时,相关信息入栈;方法返回时。相关信息出栈。
【例1】
【例2】
递归的细节问题:
- 执行一个方法时,就创建一个新的受保护的独立空间(栈空间)。
- 每一层方法的局部变量是独立的,不会相互影响。
- 如果方法中使用的是引用类型变量(比如数组、对象),各个方法就会共享该引用类型的数据。
- 递归必须向退出递归的条件逼近,否则就是无限递归,出现
StackOverflowError,栈溢出。
练习:
(1)已知斐波那契数列:1,1,2,3,5,13…使用递归的方式求出第n项。
public class Test {
public static void main(String[] args) {
Tool tool = new Tool();
int n = 7;
int res = tool.fibonacci(n);
System.out.println(res);
}
}
class Tool {
public int fibonacci(int n) {
if (n == 1 || n == 2)
{
return 1;
}else {
return fibonacci(n-1) + fibonacci(n-2);
}
}
}
(2)有一堆桃子,猴子第一天吃了其中的一 半,并再多吃了一个。以后每天都吃其中的一半,然后再多吃一个。当到第10天时,想再吃时(还没吃)发现只有1个桃子了。问:最初共多少个桃子?
public class Test {
public static void main(String[] args) {
Tool tool = new Tool();
int day = 1;
int res = tool.peachNum(day);
if (res!=-1)
{
System.out.println("第"+day+"天桃子个数是: "+res);
}else{
System.out.println("应输入1~10的数字");
}
}
}
class Tool {
public int peachNum(int day) {
if (day == 10)
{
return 1;
}else if(day>=1 && day<=9) {
return (peachNum(day+1)+1) * 2;
}else {
return -1;
}
}
}
(3)老鼠出迷宫,找到一条路径,从①处走到②处。
(待补充)
2.6 方法的重载
2.6.1 基本介绍
重载:Java 允许同一个类有多个同名方法,但要求形参列表不一致(根据这里判断是否是重载就够了)。
重载的好处:
(1)减轻了起名的麻烦
(2)减轻了记名的麻烦
(3)利于接口编程
【例1】方法重载演示
public class Test {
public static void main(String[] args) {
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 double calculate(int n1, double n2) {
System.out.println("calculate(int n1, double n2) 被调用..");
return n1 + n2;
}
public double calculate(double n1, int n2) {
System.out.println("calculate(double n1, int n2) 被调用..");
return n1 + n2;
}
public int calculate(int n1, int n2, int n3) {
System.out.println("calculate(int n1, int n2, int n3) 被调用..");
return n1 + n2 + n2;
}
}
输出结果:
calculate(int n1, int n2) 被调用..
3
calculate(double n1, int n2) 被调用..
3.1
calculate(int n1, double n2) 被调用..
3.1
2.6.2 使用细节
(1)方法名:必须相同。
(2)形参列表:必须不同(形参类型或个数或顺序,至少有一样不同,参数名无要求)。
(3)返回类型:无要求。
【例2】重载对参数名称无要求,所以下面两个方法只是“方法的重复定义”,不构成方法重载,而且是错误的。
class MyCalculator {
public int calculate(int n1, int n2) {
System.out.println("calculate(int n1, int n2) 被调用");
return n1 + n2;
}
public int calculate(int a1, int a2) {
System.out.println("calculate(int n1, int n2) 被调用");
return a1 + a2;
}
}
【例3】重载对返回类型无要求,所以下面两个方法也不构成重载。
class MyCalculator {
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;
}
}
【例4】与void show(int a,char b,double c){}构成重载的有:
- void show(int x,char y,double z){}
- int show(int a,double c,char b){}
- void show(int a,double c,char b){}
- boolean show(int c,char b){}
- void show(double c){}
- double show(int x,char y,double z){}
- void shows(){}
【例5】重载中的优先级:如果有多个重载方法可供调用,则优先调用参数类型匹配度高的一个。如methods.max(3.2, 2.1, 5)优先调用方法2,如果没有方法2才会调用方法1。
public class Test {
public static void main(String[] args) {
Methods methods = new Methods();
System.out.println(methods.max(3.2, 2.1, 5));
}
}
class Methods {
public double max(double n1, double n2, double n3) {//方法1
double t = n1 > n2 ? n1:n2;
return t > n3 ? t:n3;
}
public double max(double n1, double n2, int n3) {//方法2
double t = n1 > n2 ? n1:n2;
return t > n3 ? t:n3;
}
}
2.7 可变参数
2.7.1 基本介绍
可变参数:Java 允许将同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法,可以通过可变参数实现。
基本语法:
访问修饰符 返回类型 方法名(数据类型... 形参名) {
}
【例1】一般重载方法与可变参数使用的对比:
//一般重载方法,比较笨
public class Test {
public static void main(String[] args) {
Methods m = new Methods();
System.out.println(m.sum(1, 5, 100)); //106
System.out.println(m.sum(1,19)); //20
}
}
class Methods {
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;
}
}
//可变参数,灵活
public class Test {
public static void main(String[] args) {
Methods m = new Methods();
System.out.println(m.sum(1, 5, 100)); //106
System.out.println(m.sum(1,19)); //20
}
}
class Methods {
public int sum(int... nums) {
int res = 0;
//可变参数的使用与数组相同
for(int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
}
2.7.2 使用细节
-
可变参数的实参可以为0个或任意多个。
-
可变参数的实参可以为数组。
public class Test { public static void main(String[] args) { int[] arr = {1, 2, 3}; Methods m = new Methods(); m.f1(arr); } } class Methods { public void f1(int... nums) { System.out.println(nums.length);//3 } }
-
可变参数的本质就是数组。
-
可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后(保证形参和实参的唯一对应关系)。
-
一个形参列表中只能出现一个可变参数(保证形参和实参的唯一对应关系)。
【例2】封装一个可变参数方法,同时具备返回姓名和两门课总成绩、返回姓名和三门课总成绩、返回姓名和五门课总成绩的功能。
public class Test {
public static void main(String[] args) {
Methods m = new Methods();
System.out.println(m.showScore("milan" , 90.1, 80.0 ));
System.out.println(m.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
}
}
class Methods {
public String showScore(String name ,double... scores ) {
double totalScore = 0;
for(int i = 0; i < scores.length; i++) {
totalScore += scores[i];
}
return name + "有" +scores.length + "门课, 成绩总分为" + totalScore;
}
}
输出结果:
milan有2门课, 成绩总分为170.1
terry有5门课, 成绩总分为280.6
3. 作用域
3.1 基本使用
在Java中,主要的变量就是属性(成员变量)和局部变量:
- 全局变量:即属性,作用域为整个类。
- 局部变量:即属性之外的其他变量,作用域为定义它的代码块,一般指在成员方法中定义的变量。
- 全局变量(属性)可以不赋值,直接使用,因为有默认值;局部变量必须先赋值再使用,因为没有默认值。
class Methods {
//属性(成员变量)在定义时,可以直接赋值
int age = 10;
double weight; //默认值是 0.0
public void cry() {
//局部变量
int n = 10;
String name = "jack";
}
}
3.2 注意事项和细节
-
属性和局部变量可以重名,访问时遵循就近原则。
public class Test { public static void main(String[] args) { Methods m = new Methods(); m.say();//输出king } } class Methods { String name = "jack"; public void say() { //属性和局部变量可以重名,访问时遵循就近原则 String name = "king"; System.out.println(name); } }
-
在同一个作用域中,比如在同一个成员方法中,两个局部变量不能重名。
-
属性生命周期较长,伴随着对象的创建而创建,伴随着对象的销毁而销毁;局部变量生命周期较短,伴随着所在代码块的执行而创建,伴随着所在代码块的的结束而销毁。
public class Test { public static void main(String[] args) { Methods m = new Methods(); //当执行say方法时,say方法的局部变量比如 name,会创建 //当say执行完毕后,name 局部变量就销毁,但是属性(全局变量)仍然可以使用 p1.say(); } } class Methods { String name = "jack"; public void say() { String name = "king"; System.out.println(name);//输出king } }
-
全局变量 / 属性 也可以被其他类使用(通过对象来使用),有 2 种方法;局部变量只能在本类中所在的方法内使用。
使用其他类中的全局变量 / 属性——方法1
public class Test { public static void main(String[] args) { T t1 = new T(); t1.test1(); //jack } } class T { //全局变量/属性:也可以被其他类使用(通过对象来使用) public void test1() { Person p1 = new Person(); System.out.println(p1.name); } } class Person { String name = "jack"; }
使用其他类中的全局变量 / 属性——方法2
public class Test { public static void main(String[] args) { Person p2 = new Person(); T t2 = new T(); t2.test2(p2); //jack } } class T { //全局变量/属性:也可以被其他类使用(通过创建对象来使用) public void test2(Person p) { System.out.println(p.name); } } class Person { String name = "jack"; }
-
全局变量 / 属性可以加修饰符;局部变量不可以加修饰符。
4. 构造方法 / 构造器(constructor)
4.1 基本使用
构造方法,是类的一种特殊方法,主要作用是完成对新对象的初始化。它有几个特点:
- 方法名和类名相同。
- 没有返回值。
- 在创建对象时,系统会自动的调用该类的构造器完成对象的初始化。
- 方法的修饰符可以默认,也可以是 public protected private。
- 参数列表和成员方法一样的规则。
基本语法:
修饰符 方法名(形参列表){
方法体;
}
【例】构造方法 / 构造器的使用
public class Test {
public static void main(String[] args) {
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;
public Person(String pName, int pAge) {
System.out.println("构造器被调用,完成对象的属性初始化");
name = pName;
age = pAge;
}
}
输出结果:
构造器被调用,完成对象的属性初始化
p1 的信息如下
p1 对象 name = smith
p1 对象 age = 80
4.2 注意事项和细节
-
一个类可以定义多个不同的构造器,即构造器重载。
public class Test { public static void main(String[] args) { Person p1 = new Person("king", 40);//第 1 个构造器 Person p2 = new Person("tom");//第 2 个构造器 System.out.println("p1: "+p1.name+" "+p1.age);//king 40 System.out.println("p2: "+p2.name+" "+p2.age);//tom 0 } } class Person { String name; int age; //第 1 个构造器 public Person(String pName, int pAge) { name = pName; age = pAge; } //第 2 个构造器, 只指定人名,不需要指定年龄(有默认值0) public Person(String pName) { name = pName; } }
-
构造器是完成对象的初始化,并不是创建对象。在创建对象时,系统自动的调用该类的构造方法。
-
如果没有定义构造器,系统会给类生成一个无参构造器(也叫默认构造器)。下面的Dog类在被系统编译后生成的默认构造方法,可以使用javap指令反编译来看。
class Dog { }
反编译结果:
-
一旦定义了自己的构造器,默认的构造器就覆盖了,就不能再使用默认的无参构造器,除非显式地定义一下。
public class Test { public static void main(String[] args) { Dog dog = new Dog(); } } class Dog { public Dog(String dname){ //... } Dog(){//不显式地定义,Dog dog = new Dog()就通不过 //... } }
5. 对象创建流程分析
学习了构造方法后,我们来重新分析一下对象的创建流程。
public class Test {
public static void main(String[] args) {
Person p = new Person("tom", 20);
}
}
class Person
{
String name;
int age = 90;
Person(String n, int a){
name = n;
age = a;
}
}
对于上面代码,对象创建的流程为:
(1)加载Person类信息到方法区 (无论创建多少Person对象,只会加载一次)。
(2)在堆中为对象分配空间。
(3)完成对象初始化:
(3.1)默认初始化 name=null, age=0
(3.2)显式初始化 name=null, age=90
(3.3)构造器的初始化 name=”tom“, age = 20
(4)将对象在堆中的地址赋给p(p是对象名,也可以理解成是对象的引用)。
6. this关键字
6.1 this的引入和使用
先看一段代码:
public class Test {
public static void main(String[] args) {
Dog dog = new Dog("tom", 3);
dog.info();//tom 3
}
}
class Dog{
public String name;
public int age;
public Dog(String dName, int dAge){
name = dName;
age = dAge;
//如果形参改成name、age,根据就近原则,
//两个name指的都是通过形参传进来的name
//name = name;
//age = age;
}
public void info(){
System.out.println(name+ "\t" + age+ "\t");
}
}
问题:构造方法的形参名不太好,如果能够将dName改成name就好了,但是会发现按照变量的作用域原则,name的值就是null,怎么解决?这就用到了this关键字。
this关键字:Java虚拟机会给每个对象分配 this,代表当前对象。
使用this关键字解决前面变量名问题:
public class Test {
public static void main(String[] args) {
Dog dog = new Dog("tom", 3);
dog.info();//tom 3
}
}
class Dog{
public String name;
public int age;
public Dog(String name, int age){
this.name = name;//使用this关键字解决
this.age = age;
}
public void info(){
System.out.println(name+ "\t" + age+ "\t");
}
}
6.2 this的深入理解
this关键字的理解(可能不特别准确,但帮助理解):把this看成是所在对象的属性,属性值是该对象的地址(指向该对象)。
可以用hashcode验证this指向它所在的对象。
【注】Java代码在JVM虚拟机上运行,无法直接获取对象的地址。hashcode 是地址的一种映射,可以用来间接地查看对象地址是否相同,即是否为同一对象。
public class Test {
public static void main(String[] args) {
Dog dog1 = new Dog("大壮", 3);
System.out.println("main方法:dog1的hashCode = " + dog1.hashCode());
dog1.info();
System.out.println("===================================");
Dog dog2 = new Dog("大黄", 2);
System.out.println("main方法:dog2的hashCode = " + dog2.hashCode());
dog2.info();
}
}
class Dog
{
public String name;
public int age;
public Dog(String name, int age){
this.name = name;
this.age = age;
System.out.println("构造方法: this.hashCode = " + this.hashCode());
}
public void info(){
System.out.println("info方法: this.hashCode = " + this.hashCode());
System.out.println(name+ "\t" + age+ "\t");
}
}
输出结果:
构造方法: this.hashCode = 366712642
main方法:dog1的hashCode = 366712642
info方法: this.hashCode = 366712642
大壮 3
===================================
构造方法: this.hashCode = 1829164700
main方法:dog2的hashCode = 1829164700
info方法: this.hashCode = 1829164700
大黄 2
6.3 this的使用细节
-
this 关键字可以用来访问本类的属性、方法、构造器。
-
this 用于区分当前类的属性和局部变量(前面就是通过这一条引出this)。
public class Test { public static void main(String[] args) { T t = new T(); t.f3(); } } class T { String name = "jack"; int age = 100; public void f3(){ String name = "smith"; System.out.println(name+" "+age);//smith 100 System.out.println(this.name+" "+this.age);//jack 100 } }
-
访问成员方法的语法:this.方法名(参数列表)。
public class Test { public static void main(String[] args) { T t1 = new T(); t1.f2(); } } class T { public void f1(){ System.out.println("f1()方法..."); } public void f2(){ System.out.println("f2()方法..."); //第1种方式:前面讲的,访问本类中的方法不用创建对象,直接访问即可 f1(); //第2种方式 this.f1(); } }
输出结果:
f2()方法... f1()方法... f1()方法...
-
访问构造器语法:this(参数列表),注意只能在构造器中使用,即只能在构造器中访问本类中另外一个构造器, 且必须放在第一条语句。
public class Test { public static void main(String[] args) { T t2 = new T(); } } class T { 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构造器" ); } }
输出结果:
T(String name, int age构造器 T() 构造器
-
this 不能在类的外部使用,只能在类的方法中使用。
【例】定义 Person 类,里面有 name、age 属性,并提供 compareTo 比较方法,用于判断是否和另一个人相等。提供测试类 Test 用于测试,若名字和年龄完全一样,返回 true, 否则返回 false。
public class TestPerson {
public static void main(String[] args) {
Person p1 = new Person("mary", 20);
Person p2 = new Person("mary", 20);
System.out.println("p1 和 p2 比较的结果=" + p1.compareTo(p2));//true
}
}
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public boolean compareTo(Person p) {
return this.name.equals(p.name) && this.age == p.age;
}
}
7. 本章练习
【例1】编写类A01,定义方法getMax,事先求某个double数组的最大值,并返回。
public class Test {
public static void main(String[] args) {
double[] arr = {3.5, 9.2, 10.3, 8.2, 4.3};
A01 a01 = new A01();
Double max = a01.getMax(arr);
if(max != null)
System.out.println("最大值是" + max);
else
System.out.println("数组不能为空");
}
}
class A01{
public Double getMax(double[] arr){//Double可以接收double或对象作为返回值
//防止初始化时 arr=null 或 arr={}
if(arr != null && arr.length != 0){
double maxNum = arr[0];
for (int i = 1; i < arr.length; i++){//arr.length==1时不执行
if (arr[i] > maxNum){
maxNum = arr[i];
}
}
return maxNum;
}else{
return null;
}
}
}
数组为空和数组长度为0的区别:
(1)int[] arr1 :只是声明了一个数组变量,并未初始化,使用会出错.
(2)int[] arr2 = null:虽然初始化,但是一个空指针,没有指向一个有效的数组,什么都做不了,无法调用这个对象的方法,会产生空指针异常。
(3)int[] arr3 = new int[0]:声明并创建了一个数组对象,只不过长度为0,没有内容。
所以对于数组,不但要判断它是否为空指针,也需要判断它是否有内容,同时要先判断空指针再判断长度是否为0,顺序不能颠倒,因为空指针没有length属性。
【例2】编写Book类,定义方法updatePrice,实现更改某本书的价格。若价格 > 150,则更改为150,若价格 > 100,则更改为100,否则不变。
public class Test {
public static void main(String[] args) {
Book book = new Book("西游记", 134.2);
System.out.println(book.name+" "+book.price);//西游记 134.2
book.updatePrice();
System.out.println(book.name+" "+book.price);//西游记 100.0
}
}
class Book{
String name;
double price;
public Book(String name, double price){
this.name = name;
this.price = price;
}
public void updatePrice(){
if(price > 150){
price = 150;
}else if(price > 100){
price = 100;
}
}
}
【例3】定义一个圆类Circle,定义属性:半径,提供显示圆周长功能的方法,显示圆面积的方法。
在Java的Math类中有一个字段PI,它是比任何值都接近 π 的double值,即 Math.PI ≈ π。
public class Test {
public static void main(String[] args) {
Circle circle = new Circle(3);
circle.outCircum();
circle.outArea();
}
}
class Circle{
double radius;
public Circle(double radius){
this.radius = radius;
}
public void outCircum(){
System.out.println("圆的周长:"+2*Math.PI*radius);
}
public void outArea(){
System.out.println("圆的面积:"+Math.PI*radius*radius);
}
}
【例4】编程创建一 个Calei计算类,在其中定义2个变量表示两个操作数,定义四个方法实现求和、差、乘、商(要求除数为0的话,要提示)。
public class Test {
public static void main(String[] args) {
Calei Calei = new Calei(3, 0);
System.out.println(Calei.add());
System.out.println(Calei.sub());
System.out.println(Calei.mul());
Double divRes = Calei.div();
if (divRes != null){
System.out.println(divRes);
}
}
}
class Calei{
double a;
double b;
public Calei(double a, double b){
this.a = a;
this.b = b;
}
public double add(){
return a+b;
}
public double sub(){
return a-b;
}
public double mul(){
return a*b;
}
public Double div(){//注意返回类型
if(b!=0)
return a/b;
else{
System.out.println("除数不能为0");
return null;
}
}
}
【例5】分析下面代码的输出。
public class Test {
int count = 9;
public void count1() {
count=10;
System.out.println(" count1=" + count) ;
}
public void count2() {
System.out.println(" count1=" + count++ );
}
public static void main(String args[]) {
new Test().count1();
Test t1= new Test();
t1.count2();
t1.count2();
}
}
(1)new Test().count1() 先创建匿名对象,该对象中的属性count 为 9,调用count1方法后,count 为10,故该句输出count = 10。匿名对象使用一次后,就不能再使用。
(2)Test t1= new Test() 创建t1对象(与前面的匿名对象不是一个对象),该对象中的属性count 为 9。
(3)t1.count2() 先输出t1对象的count属性9,再使count自增,count变为10。
(4)t1.count2() 先输出t1对象的count属性10,再使count自增,count变为11。
输出结果:
count1=10
count1=9
count1=10
【例6】分析下面代码的输出。
class Demo{
int i= 100;
public void m () {
int j=i++;
System.out.println("i="+i);
System.out.println("j="+j);
}
}
public class Test{
public static void main(String[] args){
Demo d1 = new Demo();
Demo d2 = d1;
d2.m();
System.out.println(d1.i);
System.out.println(d2.i);
}
}
关键点: d1和d2指向的是同一个对象。
与本题解答关系不大的知识点:i 在堆中,j 在栈中。
输出结果:
i=101
j=100
101
101
【例7】method方法的调用语句为: System.out.println(method(method(10.0,20.0),100)); 试写出method方法的定义形式。
public double method(double d1, double d2) {..}
【例8】创建一个Employee类, 属性有(名字,性别,年龄,职位,薪水), 提供3个构造
方法,分别可以初始化:
(1)名字,性别,年龄,职位,薪水
(2)名字,性别,年龄
(3)职位,薪水
要求充分用构造器。
class Employee{
String name;
char gender;
int age;
String job;
double sal;
//先写属性少的构造器,这样属性多的构造器就可以复用它
public Employee(String job, double sal) {
this.job = job;
this.sal = sal;
}
public Employee(String name, char gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public Employee(String job, double sal, String name, char gender, int age) {
this(name, gender, age);//使用到前面的构造器
//this(参数列表)在构造器中访问另外一个构造器,
//必须放在第一条语句。
//this(job, sal);
this.job = job;
this.sal = sal;
}
}
【例9】将对象作为参数传递给方法。
题目要求::
(1) 定义一个Circle类,包含double型的radius属性代表圆的半径,findArea()方
法返回圆的面积。
(2) 定义一个类PassObject,在类中定义方法printAreas(),该方法的定义如下:
public void printAreas(Circle C, int times) //方法签名/声明
(3) 在printAreas() 方法中打印输出1到times之间的每个整数半径值,以及对应的面积。
例如:times为5,则输出半径1, 2, 3, 4, 5 以及对应的圆面积。
(4) 在main方法中调用printAreas() 方法,调用完毕后输出当前半径值。程序运行结果如图所示:
public class Test{
public static void main(String[] args){
PassObject obj = new PassObject();
Circle c = new Circle();
obj.printAreas(c, 5);
}
}
class Circle{
double radius;
public double findArea(){
return Math.PI*radius*radius;
}
public void setRadius(double radius){
this.radius = radius;
}
}
class PassObject{
public void printAreas(Circle c, int times){
System.out.println("circle\tareas");
for (int i=1; i<=times; i++){
//只创建了一个对象,但在求不同半径的
//圆的面积时,去动态修改了圆的半径,
//比每次都创建新对象效率高
c.setRadius(i);
System.out.println(c.radius + "\t\t" + c.findArea());
}
}
}
【例10】猜拳游戏:人与电脑玩猜拳游戏,共玩3次。先由人出拳,然后电脑出拳,每次游戏后立即显示游戏结果。3次游戏结束后,显示人与电脑分别赢的次数。(0-石头 1-剪刀 2-布)
import java.util.Scanner;
import java.util.Random;
public class Test{
public static void main(String[] args){
PerOrCom person = new PerOrCom(0);//初始化人赢的次数为0
PerOrCom computer = new PerOrCom(0);//初始化电脑赢的次数为0
Game game = new Game();
game.play(person, computer);
}
}
class PerOrCom{//人或电脑
int current;//当前猜拳数字
int success;//赢的次数
public PerOrCom(int success){
this.success = success;
}
public void setCurrent(int current){
this.current = current;
}
public int getSuccess(){
return success;
}
}
class Game{
public void play(PerOrCom person, PerOrCom computer) {
System.out.println("===玩家共有3次对局===");
Scanner scanner = new Scanner(System.in);
Random r = new Random();
for (int i=0; i<3; i++){
System.out.print("请出拳(0-石头 1-剪刀 2-布):");
person.setCurrent(scanner.nextInt());
computer.setCurrent(r.nextInt(3));
if ((person.current == 0 && computer.current == 1) ||(person.current == 1 && computer.current == 2)||(person.current == 2 && computer.current == 0)){
person.success++;
System.out.println("你出的是"+person.current+",电脑出的是"+computer.current+",你赢了");
}else if(person.current == computer.current){
System.out.println("你出的是"+person.current+", 电脑出的是"+computer.current+", 平局");
}else{
computer.success++;
System.out.println("你出的是"+person.current+", 电脑出的是"+computer.current+", 你输了");
}
}
System.out.println("游戏结束。你赢了"+person.success+"次, 电脑赢了"+computer.success+"次");
}
}