1.简介
俺就一小白,半途想记录一下,有错就改,这当自己的小笔记,知识点细小了一点,欢迎大家补充,同时愿自己坚持下来。很多知识点都在代码里面备注,为了方便自己就不一一拿出来了。主要内容:Java方法,类,对象,递归。递归思维解决——斐波那契数,猴子吃桃,迷宫,汉诺塔等。目录齐全。
2.类和对象
类和对象: 类是创建一个数据类型; 对象就是一个具体的事物。
public class Object_Base01 {
/*
类和对象:
类是创建一个数据类型;int,char.double
对象就是一个具体的事物。
*/
public static void main(String[] args) {
/*
张老太养了两只猫猫:一只名家叫小白,今年3岁,白色。
还有一只叫小花,今年100岁,花色。请编写一个程序,
当用户输入小猫的名字时就显示该猫的名字,年龄,颜色。
如果用户输入的小猫名错误,则显示 张老太没有这只猫猫。
*/
// //1.单独变量==》1)不利于数据的管理; 2)效率低下
// String dog1Name = "小白";
// String dog2Name = "花花";
//
// int dog1Age = 18;
// int dog2Age = 38;
//
// //2.数组==》1)数据类型无法体现 2)只能通过下标表现出来
// String dog1[] = {"小白", "18", "白色"};
// String dog2[] = {"小花", "38", "花色"};
//3.数组
//实例化一个对象
Cat cat1 = new Cat(); //创建一只猫,并赋值给 cat1
cat1.name = "小白";
cat1.age = 18;
cat1.color = "白色";
cat1.weight = 23.34;
//cat2 是对象名(对象引用)
//new Cat() 创建的对象空间才是真正的对象
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 38;
cat2.color = "花色";
cat2.weight = 9.32;
//怎么访问
System.out.println("第一只猫" + cat1.name + "\t" + cat1.age
+ "\t" + cat1.color + "\t" + cat1.weight);
System.out.println("第二只猫" + cat2.name + "\t" + cat2.age
+ "\t" + cat2.color + "\t" + cat2.weight);
}
}
class Cat{
// 属性/成员变量/字段
String name;
int age;
String color;
double weight;
// 属性既可以是基本数据类型,也可以是引用类型(数组,对象)
//创建空间的方法:
// 1)直接创建;Cat cat = new Cat()
// 2)先声明再创建: Cat cat; caty = new Cat()
//访问属性:
// 对象名.属性名
//类与对象
/*
Java 内存的结构分析
1.栈:一般存放基本数据类型
2.堆:存放对象(Cat cat,数组等)
3.方法区L:常量区(常量,比如字符串),类加载信息
4.示意图[Cat(name,age,prince]
*/
// Person p = new Person();
// p.name = "jack";
// p.age = 10;
/*
创建对象流程简单分析:
1.先加载Person类信息
2.在堆中分配空间,进行默认初始化
3.把地址给p,p指向的对象
4.进行指定初始化 p.name = "jack"; p.age = 10;
*/
}
3.方法
方法调用: // 1.方法写好后,不去调用,不会输出 // 2.先创建一个对象,再去调用
方法调用小结: //1.当程序执行到方法时,就会开辟一个独立的空间(栈空间) //2.当方法执行完毕,或者执行到return语句时,就会返回 //3.返回到调用的地方 //4.返回后继续执行方法后的语句
public class Method_02 {
public static void main(String[] args) {
//方法调用:
// 1.方法写好后,不去调用,不会输出
// 2.先创建一个对象,再去调用
Person p1 = new Person();
p1.name = "皓泽";
p1.speak();
p1.cal01();
p1.cal02(5);
int returnRes = p1.getSum(2,34); //调用getSum,同时进行赋值
System.out.println("getSum返回值:" + returnRes);
System.out.println(p1.name);
}
}
class Person{
String name;
int age;
// 1. public 表示方法是公开的
// 2. void: 表示方法没有返回值
// 3.speak() speak是方法名, ()形参列表
// 4. {}方法体, 可以写物品,要执行的代码
public void speak(){
System.out.println("我是帅比");
}
//添加cal01 成员方法,计算1-1000的和
public void cal01(){
int res = 0;
for (int i = 0; i <= 1000; i++) {
res += i;
}
System.out.println("计算结果为:" + res);
}
//添加cal02 成员方法,计算1-n的和
//解读:
//1.(int n) 形式列表, 表示当前有一个形参 n,可以从用户输入
public void cal02(int n){
int res1 = 0;
for (int i = 0; i <= n; i++) {
res1 += i;
}
System.out.println("计算结果:" + res1);
}
//添加getSum成员的方法,可以计算两个数的和
//解读:
// 1.public 表示方法是公开的
// 2.int :表示方法执行后,返回一个 int 值
// 3.getSum 方法名
// 4.(int num1, int num2) 形参列表,2个形参,可以接受用户传入的两个数
public int getSum(int num1,int num2) {
int res = num1 + num2;
return res; //return语句
//方法调用小结:
//1.当程序执行到方法时,就会开辟一个独立的空间(栈空间)
//2.当方法执行完毕,或者执行到return语句时,就会返回
//3.返回到调用的地方
//4.返回后继续执行方法后的语句
}
}
4.为什么需要成员方法
1.成员方法的好处: // 提高代码的复用性 // 可以将实现的细节封装起来然后供其他用户来调用即可。
public class Method_03 {
//为什么需要成员方法
public static void main(String[] args) {
int map[][] = {{1,2,4},{3,5,9},{6,4,2}};
Mytool tool = new Mytool();
tool.printArr(map);
tool.printArr(map);
tool.printArr(map);
}
}
class Mytool{ //类
//定义一个输出数组方法
public void printArr(int map[][]){
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();
System.out.println("==========");
}
}
}
public class MethodDetail_04 {
//1.一个方法最多有一个返回值 【思考:如何返回多个值:可以使用数组】
public static void main(String[] args) {
AA a = new AA();
int res[] = a.getSumAndSub(6,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;
}
//2..返回类型可以为任意类型,包含基本类型或引用类型(数组,对象)
// 看上述代码getSumAndSnb
// 3.如果方法要求有返回数据类型,则方法体中最后的执行语句必须为return 值;而且要求返回值类型必须和return的值类型一致或兼容
public double f1(){ //要求
double d1 = 1.1 * 3;
int a = 100;
return a; //返回 //int->double 兼容
}
// 4.如果方法是void,则方法体中可以没有return语句,或者 只写 return;
// 5.方法名遵循驼峰命名法,最好见名知义,表达出该功能的意思即可,比如 得到两个数的和 getsum,开发中按照规范
/*
二.形参列表
1.一个方法可以有0个参数,也可以有多个参数,中间用逗号隔开,比如 getSum(int n1,int n2)
2.参数类型可以为任意类型,包含基本类型或引用类型,比如 printArr(int[][] map)
3.调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型 的参数!【getSum)
4.方法定义时的参数称为形式参数,简称形参;方法调用时的传入参数称为实际参数,简称实参
实参和形参的类型要一致或兼容、个数、顺序必须一致![演示]
方法体
里面写完成功能的具体的语句,可以为输入、输出、变量、运算、分支、循环、方法调用,
但里面不能再定义方法!即:方法不能嵌套定义。[演示]
*/
/*
三.方法调用细节说明
1.同一类中可以直接调用
2.跨类的方法调用,需要通过对象名调用------类似于 main 调用 class 类
3.*跨类的方法调用和方法的访问修饰符相关(后面细讲)
*/
}
练习题
public class MethodExercise_05 {
public static void main(String[] args) {
BA b = new BA();
boolean c = b.num(1);
System.out.println(c); //接受return的返回值
//BA d = new BA();
b.print(4,32,'#');
}
}
//编写一个类 AA,判断一个数是奇数还是偶数,返回boolean
class BA{
public boolean num(int a) {
// if(a % 2 == 1){
// return true;
// }else{
// return false;
// }
return (a % 2 == 1) ? true : false;
}
//按要求,输出对应的行和列的字符
public void print(int row,int col,char c){
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
System.out.print(c);
}
System.out.println();
}
}
}
import java.util.Scanner;
public class MethodParameter_06 {
//成员方法传参机制
// 1.形参的任何变化都不会影响实参;
// 2.引用类型传递的是地址,可以通过形参来影响实参;
// 形参和实参指向同一个存储地址空间,因此,形参改变空间的内容,会对地址空间内容发生永久性变化
//3.
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
System.out.print("输入第一个数 = ");
int a = myScanner.nextInt();
System.out.print("输入第二个数 = ");
int b = myScanner.nextInt();
AAA c = new AAA();
c.swap(a,b);
}
}
class AAA{
public void swap(int a,int b){
System.out.println("交换前\n a = " + a + "\t" + "b = " + b);
a = a + b;
b = a - b;
a = a - b;
System.out.println("交换后\n a = " + a + "\t" + "b = " + b);
}
}
克隆方法
public class MethodExercise_07 {
//克隆对象:要求新对象与旧对象是两个独立的对象,且属性相同
public static void main(String[] args) {
Persons p = new Persons();
p.name = "minhao";
p.age = 19;
MyTools tools = new MyTools(); //创建一个tools对象
Persons p2 = tools.copyPersons(p);
//到此 p 和 p2是person对象,但是是两个独立的对象,属性相同
System.out.println("age1 = " + p.age + "\t" + "name1:" + p.name);
System.out.println("age2 = " + p2.age + "\t" + "name2:" + p2.name);
System.out.println("p == p2");
}
}
class Persons{
String name;
int age;
}
class MyTools{
public Persons copyPersons(Persons p){
//创建一个新对象
Persons p2 = new Persons(); //方法之间的调用
p2.name = p.name;//把原来对象的名字赋给p2.name
p2.age = p.age;//把原来对象的年龄赋给p2.age
return p2;
}
}
5.递归
1)递归的重要规则
递归的重要规则: 1.执行一个方法时,就创建一个新的受保护的独立空间(栈空间) 2.方法的局部变量是独立的,不会相互影响,比如n变量 3.如果方法中使用的是引用类型变量(比如数组),就会共享该引用类型的数据. 4.递归必须向退出递归的条件逼近,否则就是无限递归,出现StackOverflowError,死龟了:) 5.当一个方法执行完毕,或者遇到return,就会返回,遵守谁调用,就将结果返回给谁, 同时当方法执行完毕或者返回时,该方法也就执行完毕。
import java.util.Scanner;
public class Recursion_08 {
//递归:自己调用自己
public static void main(String[] args) {
T t1 = new T(); //定义一个对象t1
t1.test(9);
//Scanner myScanner = new Scanner(System.in);
//int i = myScanner.nextInt();
int res = t1.factorial(5);
System.out.println("res=" + res);
}
}
class T{
public void test(int n){
if (n > 2){
test (n - 1);
}
System.out.println("n = " + n);
}
public int factorial(int n){ //阶乘
if (n==1){
return 1;
}else{
return factorial(n - 1) * n;
}
}
}
2)斐波那契数(必备)
3)猴子吃桃(蓝桥杯)
import java.util.Scanner;
public class RecursionExercise_09 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
System.out.println("你想知道第几个数的斐波那契数:");
int n = myScanner.nextInt();
M m1 = new M();
//斐波那契数
if(m1.fibonacci(n) != -1) {
System.out.println("当n = " + n + "时对应的斐波那契数 = " + m1.fibonacci(n));
}else{
System.out.println("滚");
}
//猴子吃桃
System.out.println("你想知道第几天的桃子数量:");
int day = myScanner.nextInt();
int peachNum = m1.peach(day);
if(peachNum != -1){
System.out.println("第"+ day + "天的桃子数量为" + m1.peach(day));
}else{
System.out.println("滚");
}
}
}
class M {
/*递归写出斐波那契数:1,1,2,3,5,8,13......给你一个整数,求出他的值是多少
思路:
1.n = 1;斐波那契数 = 1
2.n = 2;斐波那契数 = 1
3.n = 3;斐波那契数 = 2
4.n = 4;斐波那契数 = 3
*/
public int fibonacci(int n) {
if (n >= 1) {
if (n == 1 || n == 2) {
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
} else {
System.out.println("你的输入有误");
return -1;
}
}
/*
猴子吃桃子问题:有一堆桃子,猴子第一天吃了其中的一半,并再多吃了一个!
以后每天猴子都吃其中的一半,然后再多吃一个。当到第10天时,想再吃时(即还没吃),
发现只有1个桃子了。问题:最初共多少个桃子?
思路:
1. 第10天,1个桃子
2. 第9天,(day10 + 1) * 2 = 4个桃子
3. 第8天,(day9 + 1) * 2 = 10个桃子
*/
public int peach(int day){
if(day == 10){
return 1;
}else if(day >= 1&&day <= 9){
return (peach(day + 1) + 1) * 2;
}else{
System.out.println("day的范围不在规定内");
return -1;
}
}
}
4)迷宫
public class MiGong_10 {
public static void main(String[] args) {
//思路:
//1.创建八行其列的迷宫,用二维数组表示
//2.先规定 map 数组的元素值: 0 表示可以走, 1 表示不能走
int map[][] = new int[8][7];
//3.将第一行和最后一行设置为 1
for (int i = 0; i < 7; i++) {
map[0][i] = 1;
map[7][i] = 1;
}
//4.将最左边和最右边的设置为 1
for (int i = 0; i < 8; i++) {
map[i][0] = 1;
map[i][6] = 1;
}
//5.剩余障碍物
map[3][1] = 1;
map[3][2] = 1;
//输出当前地图
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();
}
//使用findway给老鼠找路
G g1 = new G();
g1.findway(map,1,1);//引用传递
System.out.println("\n===========找路的情况==========");
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 G{
//递归回溯思想解决问题
// 回溯现象:
// 扩展:求出最短路径 a.穷举法 b.图
// 1.findway方法就是用来找出迷宫路径
// 2.找到返回true 否则返回false
// 3.map 就是二维数组,即表示迷宫
// 4.i,j就是老鼠的位置,初始化位置【1.1】
// 5.因为是递归找路,先规定要求
// 0 表示可以走, 1 表示障碍物,2 表示可以走, 3 表示走过,但不能走通
// 6.当map[6][5] = 2 时,就表明找到通路了,否则继续找
// 7.选择合适的策略下-->右-->上-->左
public boolean findway(int map[][], int i,int j){
if(map[6][5] == 2){//说明已经找到路了
return true;
}else{
if(map[i][j] == 0){//当前点为0,表示可以走,但还没走
//假设能够走通
map[i][j] = 2;
//使用找路的策略,来确定该位置是否真的可以走通
//下-->右-->上-->左
// if(findway(map,i + 1,j)){//下
// return true;
// }else if(findway(map,i,j + 1)){//右
// return true;
// }else if(findway(map,i - 1,j)){//上
// return true;
// }else if(findway(map,i,j - 1)){//左
// return true;
// }else{
// map[i][j] = 3;
// return false;
// }
//上-->右-->下-->左
if(findway(map,i - 1,j)){//上
return true;
}else if(findway(map,i,j + 1)){//右
return true;
}else if(findway(map,i + 1,j)){//下
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;
}
}
}
}
5)汉诺塔
public class HanoiTower_11 {
public static void main(String[] args) {
Tower tower = new Tower();
tower.move(2,'A','B','C');
}
}
class Tower{
//方法
//num 表示要移动的个数,a,b,c 分别表示A,B,C塔
public void move(int num,char a,char b,char c){
//如果 num = 1
if (num == 1){
System.out.println(a + "->" + c);
}else{
//如果有多个盘,可以看成两个, 最下面的和上面所有的盘
//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);
}
}
}
6.方法重载
public class OverLoad_12 {
public static void main(String[] args) {
/*
方法重载:
1. 方法名相同
2. 形参列表:必须不同(个数不同,类型不同,顺序不同,参数名无要求)
3. 返回值,无要求
*/
/*1.编写程序,类Methods中定义三个重载方法。方法名为m。三个方法分别接受一个int参数,两个int参数
一个字符串参数。分别执行平方运算并输出结果,相乘并输出结果,输出字符串信息。在主类main()方法中分别
用参数区别调用三个方法。
*/
Methods methods = new Methods();
methods.m(8);
methods.m(6,9);
methods.m("旧人已故");
/*2.在Methods类,定义三个重载方法max(),第一个方法,返回两个int值中的最
大值,第二个方法,返回两个double值中的最大值,第三个方法,返回三个
double值中的最大值,并分别调用三个方法。
*/
methods.max(6,9);
methods.max(10.01,9.6);
methods.max(10.1,9.6,2.5);
}
}
class Methods{
public void m(int n){
System.out.println("平方结果 = " + (n * n));
}
public void m(int n,int a){
System.out.println("相乘结果 = " + (n * a));
}
public void m(String b){
System.out.println("传入的String = " + b);
}
public void max(int a,int b){
int max = a > b ? a : b;
System.out.println("两者中的最大值 = " + max);
}
public void max(double a,double b){
double max = a > b ? a : b;
System.out.println("两者中的最大值 = " + max);
}
public void max(double a,double b,double c){
double max = a > (b > c ? b : c) ? a : (b > c ? b : c);
System.out.println("两者中的最大值 = " + max);
}
}
7.可变参数
public class VarParamenter_13 {
public static void main(String[] args) {
/*可变参数
基本概念:
java允许将同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法就可以通过可变参数实现
基本语法:
访问修饰符 返回类型 方法名(数据类型.. 形参名){
}
*/
HspMethod m = new HspMethod();
System.out.println(m.sum(100,50,10));
System.out.println(m.sum(12,56,766));
}
}
class HspMethod{
// 1.int...表示接受的是可变参数,类型是int
// 2.使用可变参数时,可以当作是数组
public int sum(int... nums){
System.out.println("接受的参数个数:" + nums.length);
int res = 0;
int sum = 0;
for (int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
}
细节
public class VarParamenterDetail_14 {
public static void main(String[] args) {
/*
注意事项:
1. 可变参数的实参可以为0个或任意多个
2. 可变参数的实参可以为数组
3. 可变参数的本质是数组
4. 可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后
5, 一个参数列表中只能出现一个可变参数
*/
//细节: 可变参数的实参可以为数组
int arr[] = {1,2,3};
TT t = new TT();
t.f1(arr);
}
}
class TT{
public void f1(int... nums){
System.out.println(nums.length);
}
//细节: 可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后
public void f2(double str,double... nums){
System.out.println();
}
}
8.作用域
public class VarScope_16 {
public static void main(String[] args) {
/*
P237.
(变量)作用域基本使用:
1. 全局变量:也就是属性,作用域为整个类体
2. 属性在定义时,可以直接赋值
3. 局部变量:一般是指变量方法中定义的变量,作用域为定义他的代码块
4. 全局变量(属性)可以不赋值,直接使用,因为有默认值,局部变量必须赋值后
才可以使用,因为没有默认值。
*/
/*
P238-P239
作用域使用细节 Detail
1. 属性和局部变量可以重名,访问时遵循就近原则
2. 在同一个作用域中,比如在同一个成员方法中,两个局部变量,不能重名。
3. 属性生命周期较长,伴随对象的创建而创建,伴随着对象的销毁而销毁。
局部变量,生命周期较短,伴随着它的代码块的执行而创建,伴随着代码块的结束而销毁。
即在一次方法调用过程中
4. 作用域的范围不同:
全局变量/属性:可以被本类或其他类使用(通过对象调用)
局部变量:只能在本类中使用
5. 修饰符不同
全局变量/属性 可以加修饰符
局部变量 不可以加修饰符
*/
}
}
9.构造器/构造方法
构造器的细节
//构造器的细节: //1. 一个类可以定义多个构造器,即构造器重载 Personn p1 = new Personn("minhao"); System.out.println("p1 name = " + p1.name); // 2.构造器名要和类名一致 // 3.构造器没有返回值 // 4.构造器是完成对象的初始化,并不是创建对象 // 5.在创建对象时,系统自动的调用该类的构造方法 //eg:p1.name = ... (错误)只能由系统调用
public class Construuctor_17 {
public static void main(String[] args) {
/*
P240
构造方法/构造器
●看一个需求
我们来看一个需求:前面我们在创建人类的对象时,是先把一个对象创建好后,
再给他的年龄和姓名属性赋值,如果现在我要求,在创建人类的对象时,
就直接指定这个对象的年龄和姓名,该怎么做?这时就可以使用构造器
● 基本语法
·[修饰符]方法名(形参列表){
方法体;
}
老韩说明:
1)构造器的修饰符可以默认,也可以是public,protected,private
2)构造器没有返回值
3)方法名 和类名字必须一样
4)参数列表 和 成员方法-样的规则
5)构造器的调用,由系统完成
基本介绍:
构造方法又叫构造器,是类的一种特殊的方法,他的作用主要是
完成对新对象的初始化。特点如下:
1.方法名和类名相同
2.没有返回值
3.在创建对象是,系统会自动的调用和该类的构造器完成对对象的初始化
*/
//P241构造器的快速入门
//在构造人类对象时,直接定义这个对象的年龄和姓名
Personn p = new Personn("haoze",18);
System.out.println("p的信息如下");
System.out.println(p.name);
System.out.println(p.age);
//P242-P243
// 构造器的细节:
//1. 一个类可以定义多个构造器,即构造器重载
Personn p1 = new Personn("minhao");
System.out.println("p1 name = " + p1.name);
// 2.构造器名要和类名一致
// 3.构造器没有返回值
// 4.构造器是完成对象的初始化,并不是创建对象
// 5.在创建对象时,系统自动的调用该类的构造方法
//eg:p1.name = ... (错误)只能由系统调用
// 6.如果程序员没有定义构造器,系统会自动给类生成一个默认无参构造器
Dog dog = new Dog();
// 7.一旦定义了自己的构造器,默认无参构造器就会被覆盖,不能使用,除非显式的定义一下
//即: Dog(){}
Dog dog1 = new Dog("zhaomin");
}
}
class Dog{
//如果程序员没有定义构造器,系统会自动给类生成一个默认无参构造器
//javac 反编译
/*
默认构造器
Dog(){
}
*/
//一旦定义了自己的构造器,默认无参构造器就会被覆盖,不能使用,除非显式的定义一下
public Dog(String dName){
//...
}
Dog(){ //显式的定义一下
}
}
class Personn{//此处用Personn是因为在同一文件夹下,我的Person已经定义过类了
String name;
int age;
// 1.没有返回值,故没有void
// 2.构造器的名称与类的名称一样,都为Personn
// 3.(String pName,int pAge) 时构造器形参列表,规则与成员方法一样
public Personn(String pName,int pAge){
System.out.println("构造器被调用~~完成对象属性的初始化");
name = pName;
age = pAge;
}
public Personn(String pName){
name = pName;
}
}
10.对象创建流程分析(面试题)
String 是引用类型 所以在常量区调用地址
Java 内存的结构分析
1.栈:一般存放基本数据类型
2.堆:存放对象(Cat cat,数组等)
3.方法区L:常量区(常量,比如字符串),类加载信息
11.this
thisDetail
public class ThisDetail_19 {
public static void main(String[] args) {
/*
ThisDetail.java
1.this关键字可以用来访问本类的属性、方法、构造器
2.this用于区分当前类的属性和局部变量
3.访问成员方法的语法:this.方法名(参数列表);
4.访问构造器语法:this(参数列表);注意只能在构造器中使用(只能构造器中访问另一个构造器
5.this不能在类定义的外部使用,只能在类定义的方法中使用。
*/
Tf t2 = new Tf();
//3.访问成员方法的语法:this.方法名(参数列表);
t2.f2();
t2.f3();
}
}
class Tf{
String name = "tom";
int num = 100;
// 访问构造器语法:this(参数列表)
// 4.访问构造器语法:this(参数列表);注意只能在构造器中使用(只能构造器中访问另一个构造器,必须放在第一条语句)
//注意:访问构造器语法:this(参数列表);必须放在第一条语句(与继承有关)
public Tf(){
this("tom",12);//必须放在第一条语句
System.out.println("Tf() 构造器");
}
public Tf(String name,int age){
System.out.println("Tf(String name,int age) 构造器");
}
public void f3(){
String name = "jack";
int num = 99;
//传统方法 就近原则
System.out.println("name=" + name + "\t" + "num = " + num);
//this调用 属性
System.out.println("name=" + this.name + "\t" + "num = " + this.num);
}
//3.访问成员方法的语法:this.方法名(参数列表);
public void f1(){
System.out.println("f1()方法..");
}
public void f2(){
System.out.println("f2()方法..");
//调用f1
//方法1:
f1();
//方法2:
this.f1();//继承细讲
}
}
Exercise
public class ThisExercise_20 {
public static void main(String[] args) {
/*
定义Person类,里面有name、age属性,并提供compareTo比较方法,用于判断是否和另一个人相等,
提供测试类TestPerson用于测试,名字和年龄完全-:一样,就返回true,否则返回false
*/
Monkey m1 = new Monkey("monkey",20);
Monkey m2 = new Monkey("monkey",18);
System.out.println("m1和m2的比较结果 = " + m1.compareTo(m2));
}
}
class Monkey{
String name;
int age;
//构造器
public Monkey(String name,int age){
this.name = name;
this.age = age;
}
//compareTo比较方法
public boolean compareTo(Monkey p){
return this.name.equals(p.name) && this.age == p.age;
}
}