目录
一、类与对象(OOP)——类
问题：张老太有两只猫，一只名字叫小白，3岁，白色；还有一只叫小花，13岁，花色。
要求：当用户输入猫的名字时，就显示该猫的名字、年龄、颜色，如果用户输入小猫名字错 误，则显示张老太没有这只猫。
使用传统定义变量的方式不利于数据的管理，效率低下；
使用数组的方式数据类型体现不出来，而且内容对应关系不明确，还不能体现猫的行为。
1、类与对象概述
介绍：类就是数据类型，自定义的数据类型，比如：猫类(Cat)-数据类型，属性： name、age、color......，行为：run、cry、eat.....；创建一个猫对象(具体的一只 猫)，就比如数字100，是创建的数据类型(类)为int的一个对象，对象就是一个具 体的实例（比如人类这个类-->对应一个具体的人）；
public class Object01{
public static void main(String[] args){
//使用OOP解决
//实例化一只猫[创建一直猫对象]
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
cat1.weight = 5.0;
//实例化第二只猫
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 15;
cat2.color = "花色";
cat2.weight = 8.23;
//怎么使用
System.out.println("第一只猫信息" + cat1.name + " " + cat1.age + " " + cat1.color + " " + cat1.weight);
System.out.println("第二只猫信息" + cat2.name + " " + cat2.age + " " + cat2.color + " " + cat2.weight);
}
}
//使用面向对象
//
//定义一个猫类 -> 自定义的数据类型
class Cat{
//属性/成员变量/field字段
String name;
int age;
String color;
double weight;
}2、对象在内存中的存在形式
3、属性/成员变量/field(字段)
介绍：属性是类的一个组成部分，一般是基本数据类型，也可以是引用数据类型（对 象、数组）。
public class Object02{
public static void main(String[] args){
}
}
class Car{
//属性、成员变量、字段field
String name;
double price;
String color;
String[] master;
}注意事项和细节说明：
a）属性的定义语法同变量，示例：访问修饰符 属性类型 属性名; ；
访问修饰符只简单介绍，之后会在下一章节讲到。
四种访问修饰符：public、proctected、默认、private。
b）属性的定义类型可以为任意类型，包含基本类型或引用类型；
c）属性如果不赋值，有默认值，规则和数组一致。
int 0; short 0; byte 0; long 0; float 0.0; double 0.0, char \u0000; boolean false; String null;
public class PropertiesDetail{
public static void main(String[] args){
Person p1 = new Person();
System.out.println("当前这个人的信息");
System.out.println("age=" + p1.age + " name=" + p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass);
}
}
class Person{
int age;
double sal;
String name;
boolean isPass;
}4、对象创建和使用
创建1：先声明，再创建
Cat cat;
cat = new Cat();
创建2：直接创建
Cat cat = new Cat();
访问：
对象名.属性名;
5、对象创建过程
Java内存结构分析：
栈：一般存放基本数据类型（局部变量）；
堆：存放对象（Cat cat，数组等）；
方法区：常量池（常量，比如字符串），类加载信息。
先加载类信息（属性和方法信息，只会加载一次）
在堆中分配空间，进行默认初始化；
把地址赋给变量名，变量名就指向对象；
进行指定初始化。
二、方法
基本介绍：在某些情况下，我们需要定义成员方法（简称方法）；比如人类：除了有一些属 性外(年龄、姓名...)，我们人类还有一些行为，比如说话、跑步等，这时候就需要 成员方法才能完成。
1、方法基本演示
a）public表示方法是公开的；
b）void表示方法没有返回值；
c）speak()：speak是方法名，()形参列表；
d）{} 方法体，可以写我们要执行的代码；
public class Method01{
public static void main(String[] args){
//先创建对象，然后调用方法
Person p1 = new Person();
p1.speak();
p1.cal01();
p1.cal02(5); //调用cal02方法，同时给n = 5
p1.cal02(10);
//调用getSum方法，同时num1=10, num2=20
//把方法getSum返回的值赋给变量returnRes
int returnRes = p1.getSum(10, 20);
System.out.print("getSum方法返回的值=" + returnRes);
}
}
class Person{
//方法的创建
//public表示方法是公开的
//void表示方法没有返回值
//speak()：speak是方法名，()形参列表
//{} 方法体，可以写我们要执行的代码
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("cal01计算结果=" + res);
}
//cal02成员方法，接受一个数n，计算从1-n和
//(int n)形参列表，表示当前有一个形参n，可以接受用户输入
public void cal02(int n){
int res = 0;
for(int i = 0; i <= n; i++){
res += i;
}
System.out.println("cal02计算结果=" + res);
}
//创建getSum成员方法，可以计算两个数的和
//public表示方法是公开的
//int表示方法执行后，返回一个int值
//getSum方法名
//(int num1, int num2)形参列表，两个形参，可以接受用户传入的两个数
//return res; 表示把res的值返回
public int getSum(int num1, int num2){
int res = num1 + num2;
return res;
}
}2、方法调用机制
a）当程序执行到方法时，就会开辟一个独立的空间（栈空间）；
b）当方法执行完毕时，或者执行到return语句时，就会返回；
c）返回到调用方法的地方；
d）返回后，继续执行方法后面的代码；
e）当main方法（栈）执行完毕，整个程序退出。
3、使用方法的必要性
a）提高了代码的复用性；
b）可以将实现的细节封装起来，然后供其他用户来调用即可。
4、方法的定义
访问修饰符 返回数据类型 方法名((形参)参数列表...){ //方法体
语句;
return 返回值;
}a）参数列表：表示成员方法输入；
b）数据类型（返回类型）：表示成员方法输出，void表示没有返回值；
c）方法主体：表示为了实现某一功能代码块；
d）return不是必须的。
5、注意事项和使用细节
访问修饰符：（作用是控制 方法 使用的范围），如果不写就是默认访问[有四种： pubilc、protected、默认和private]。
返回类型：
a）一个方法最多有一个返回值（返回多个可以返回数组）；
b）返回类型可以为任意类型，包含基本类型和引用类型（数组、对象）；
c）如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return 值； 而且要求返回值类型必须和return的值类型一致或兼容；
d）如果方法是void，则方法体中可以没有return语句，或者只写return。
方法名：遵循驼峰命名法，最好见名知意，表达出该功能的意思即可。
形参列表：
a）一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开；
b）参数类型可以为任意类型，包含基本类型或引用类型；
c）调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数；
d）方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参 数，简称实参，实参和形参的类型要一直或兼容，个数、顺序必须一致。
方法体：里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循 环、方法调用，但是里面不能再定义方法！即：方法不能嵌套定义。
方法调用细节说明：
a）同一个类中的方法调用：直接调用即可；
b）跨类中A类方法调用B类方法：需要通过对象名调用；
注意：跨类的方法调用和方法的访问修饰符有关。
6、方法传参机制（重点）
a）基本数据类型的传参机制
看下面这段代码的执行结果
public class MethodParameter01{
public static void main(String[] args){
int a = 10;
int b = 20;
AA obj = new AA();
obj.swap(a, b);
System.out.println("main方法 a=" + a + "\tb=" + b);
}
}
class AA{
public void swap(int a, int b){
//完成了a和b的交换
System.out.println("a和b交换前的值\na=" + a + "\tb=" + b);
int temp = a;
a = b;
b = temp;
System.out.println("a和b交换后的值\na=" + a + "\tb=" + b);
}
}结果：
结论：基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参！
b）引用数据类型的传参机制
看下面这段代码的执行结果
public class MethodParameter02{
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");
}
}
}
class B{
public void test100(int[] arr){
arr[0] = 200;
System.out.println("tast100的arr数组：");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
}
}结果：
结论：引用类型传递的是地址（传递的也是值，只不过值是地址），可以通过形参 影响实参。
c）克隆对象
public class MethodExercise02{
public static void main(String[] args){
//编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。
//克隆对象
//注意要求得到新对象和原来的对象是两个独立的对象，只是它们属性相同
Person p1 = new Person();
p1.name = "yishan";
p1.age = 21;
MyTools tools = new MyTools();
Person p2 = tools.copyPerson(p1);
System.out.println("name=" + p2.name);
System.out.println("age=" + p2.age);
System.out.print(p1 == p2);//如果地址不一样，返回false，说明两个对象独立存在
}
}
class Person{
String name;
int age;
}
class MyTools{
//方法的返回类型 Person
//方法的名字 copyPerson
//方法的形参 (Person p)
//方法体，创建一个新对象，并复制属性，返回即可
//
public Person copyPerson(Person p){
//创建一个新的对象
Person p2 = new Person();
p2.name = p.name;
p2.age = p.age;
return p2;
}
}三、方法实践——递归
基本介绍：递归就是方法自己调用自己，每次调用时传入不同的变量；递归有助于编程者解 决复杂问题，同时可以让代码变得简洁。
可以解决的问题：
a）数学问题：八皇后问题、汉诺塔、阶乘问题、迷宫问题、球和篮子；
b）一些算法中使用：快速排序、归并排序、二分查找、分治算法等；
c）将用栈解决的问题-->递归代码比较简洁。
public class Recursion01{
public static void main(String[] args){
T t1 = new T();
t1.test(4);
}
}
class T{
public void test(int n){
if(n > 2){
test(n-1);
}
System.out.println("n=" + n);
}
}运行机制：
递归调用重要规则：
a）执行一个方法时，就创建一个新的受保护的独立空间（栈空间）；
b）方法的局部变量是独立的，不会互相受影响；
c）如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据；
d）递归必须向退出递归的条件逼近，否则就是无限递归；
e）当一个方法执行完毕，或者遇到return，就会返回；遵守谁调用，就将结果返回给谁； 同时当方法执行完毕或者返回时，该方法也就执行完毕。
案例一：递归阶乘
public class Recursion011{
public static void main(String[] args){
T t1 = new T();
int res = t1.factorial(5);
System.out.println("res=" + res);
}
}
class T{
public int factorial(int n){
if(n == 1){
return 1;
}else{
return factorial(n - 1) * n;
}
}
}案例二： 递归斐波那契数列
斐波那契数：1，1，2，3，5，8，13......
public class RecursionExercise01{
public static void main(String[] args){
T t1 = new T();
int n = 100;
int res = t1.fibonacci(n);
if(res != -1){
System.out.print("当n=" + n + "时，对应的斐波那契数是" + res);
}
}
}
class T{
//使用递归方式求出斐波那契数，给一个整数n，求出它的值
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("要求输入n>=1并且n为整数");
return -1;
}
}
}案例三：猴子吃桃问题
猴子吃桃问题：有一堆桃子，猴子第一天吃掉了其中的一半，并且再多吃了一个；以后 每天猴子都吃掉其中的一半，然后再多吃一个，当到第10天时，再想吃 时（即还没有吃），发现只有一个桃子了；问：某一天有几个桃子？
public class RecursionExercise01{
public static void main(String[] args){
int day = 8;
int peachNum = t1.peach(day);
if(peachNum != -1){
System.out.println("第" + day + "天有" + peachNum + "个桃");
}
}
}
class T{
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.print("day在1-10的整数！！！");
return -1;
}
}
}案例四：老鼠出迷宫
public class MiGong{
public static void main(String[] args){
//思路
//1、先创建迷宫，用二维数组表示 int[][] map = new int[8][7]
//2、规定map数组的元素值：0表示可以走；1表示障碍物
int[][] map = new int[8][7];
//3、将最上面一行和最下面一行全部设为1
for(int i = 0; i < map[i].length; i++){
map[0][i] = 1;
map[map.length-1][i] = 1;
}
//4、将最右边的一列和最左边的一列全部设为1
for(int i = 0; i < map.length; i++){
map[i][0] = 1;
map[i][map[i].length-1] = 1;
}
//5、设置障碍物
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();
}
//使用fingWay找路
T t1 = new T();
t1.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 T {
//使用递归回溯的思想解决
//
//解读
//1、findWay方法就是专门来找出迷宫的路径
//2、如果找到，就返回true，否则返回false
//3、map就是二维数组，即表示迷宫
//4、i, j就是当前坐标
//5、因为我们是递归的找路，所以我们先规定 map 数组各个值的含义
// 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;
}
}else{
return false;
}
}
}
}案例五：汉诺塔
public class HanoiTower{
public static void main(String[] args){
Tower t1 = new Tower();
t1.move(4, 'A', 'B', 'C');
}
}
class Tower{
//num表示要移动的个数，a, b, c分别表示A塔、B塔、C塔
public void move(int n, char a, char b, char c){
if(n == 1){
System.out.println(a + "->" + c);
}else{
//如果有多个盘，可以看成两个，最下面和最上面的所有盘
//1 先移动 a 上面所有的盘移到 b ，借助 c
move(n-1, a, c, b);
//2 把最下面的这个盘移动到 c
System.out.println(a + "->" + c);
//3 再把 b 上面所有盘移到 c ，借助a
move(n-1, b, a, c);
}
}
}案例六：八皇后
介绍：在8x8格的国际象棋盘上摆放八个皇后，使其不能互相攻击；即：任意两个皇后 都不能处于同一行、同一列或同一斜线上，问有多少种摆法？
public class Queens {
// 八皇后问题，在一个8×8的国际象棋棋盘上摆放8个皇后，摆放需遵守皇后不能处于同一行、同一列、同一斜线上，问有多少种摆法
int max = 8;//皇后个数
static int count = 0;//记录有多少种摆法
// 初始化一个数组用于存放结果
/*
* 这里用一维数组存放数据就可以了，这里一维数组中的值存放的是皇后的列坐标，
* 因为规定皇后是不能摆放在同一行，所以每一行只有一个皇后 ； 一维数组 arr
* 的第一个值就是 棋盘第一行皇后的列坐标值，第二个值就是皇后在棋盘第二行的列坐标值
*/
int[] arr = new int[max];
public static void main(String[] args) {
// TODO Auto-generated method stub
Queens queen = new Queens();
queen.PutQueen(0);
System.out.println("共有"+count+"种摆法");
}
//写一个摆皇后的方法
public void PutQueen(int n) {
if(n==max) {//因为n是从0开始增加，即n=0表示放第一个皇后，当n==max时表示皇后已经摆完了
Print();
return;
}
for(int i=0;i<max;i++) {
arr[n]=i;//放置第一个皇后
if(judge(n)) {//判断皇后的位置是否冲突，不冲突继续放下一个皇后
PutQueen(n+1);
}
}
}
// 写一个方法，判断皇后在该位置是否会引起冲突，即在同一行或同一列或同一斜线
public boolean judge(int n) {
for (int i = 0; i < n; i++) {
/*
* 1. 判断 皇后是否在同一列，只需判断皇后的列坐标是否相等即可，即arr[i] == arr[n]
* 2.判断皇后是否在同一斜线上，只需判断两个皇后的列坐标之差的绝对值与其横坐标之差的绝对值是否相等即可，
* 即Math.abs(n - i) == Math.abs(arr[i] - arr[n])
* */
if (arr[i] == arr[n] || Math.abs(n - i) == Math.abs(arr[i] - arr[n])) {
return false;//违反了规则，返回false
}
}
return true;
}
//输出
public void Print() {
// TODO Auto-generated method stub
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i] + " ");
}
count++;
System.out.println();
}
}
四、方法重载
基本介绍：java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！
比如：System.out.println(); out是PrintStream类型
重载的好处：
a）减轻了起名的麻烦；
b）减轻了记名的麻烦。
重载使用细节：
a）方法名：必须一样；
b）形参列表：不能一样（顺序、类型、数量等）；
c）返回类型：无要求。
public class OverLoad01{
public static void main(String[] args){
MyCalculator a = new MyCalculator();
a.calculate(3, 4);
a.calculate(3, 4.2);
a.calculate(3.3, 5);
a.calculate(3, 4, 5);
}
}
class MyCalculator{
public void calculate(int n, int m){
int sum = 0;
sum = m+n;
System.out.println("m+n=" + sum);
}
public void calculate(int n, double m){
double sum = 0;
sum = m+n;
System.out.println("m+n=" + sum);
}
public void calculate(double n, int m){
double sum = 0;
sum = m+n;
System.out.println("m+n=" + sum);
}
public void calculate(int n, int m, int o){
int sum = 0;
sum = m+n+o;
System.out.println("m+n=" + sum);
}
}五、可变参数
基本概念：Java允许将同一个类中多个同名同功能但参数个数不同的方法封装成一个方法。
基本语法：
访问修饰符 返回类型 方法名(数据类型...形参名){
}public class Varparameter01{
public static void main(String[] args){
Method a = new Method();
System.out.print(a.sum(1, 2, 4, 123));
}
}
class Method{
//可以计算2、3、4...等等数的和
//可以使用方法重载
//但是可变参数更合理
//
//int...表示接受的是可变参数，类型是int，即可以接受多个int(0-多)
//使用可变参数时，可以当作数组来使用，即nums可以当作数组
public int sum(int... nums){
System.out.println("接受的参数个数" + nums.length);
int sum = 0;
for(int i = 0; i < nums.length; i++){
sum += nums[i];
}
return sum;
}
}注意事项和使用细节：
a）可变参数的实参可以为0个或任意多个；
b）可变参数的实参可以为数组；
c）可变参数的本质就是数组；
d）可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后；
e）一个形参列表中只能出现一个可变参数。
public class VarparameterExercise{
public static void main(String[] args){
HspMethod a = new HspMethod();
System.out.println(a.showScore("李明", 69, 45, 92));
System.out.println(a.showScore("张华", 91, 65, 79, 82, 88));
}
}
class HspMethod{
public String showScore(String name, int... score){
int sum = 0;
for(int i = 0; i < score.length; i++){
sum += score[i];
}
return name + score.length + "门课总分是：" + sum;
}
}六、作用域（重点）
基本概念：
a）在Java编程中，主要的变量就是属性（成员变量）和局部变量；
b）我们所说的局部变量一般是指在成员方法中定义的变量；
c）Java中作用域的分类：
全局变量：也就是属性，作用域为整个类体；
局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中；
d）全局变量可以不赋值，直接使用，因为有默认值，局部变量必须赋值后才能使用， 因为没有默认值。
public class VarScope{
public static void main(String[] args){
HspMethod a = new HspMethod();
System.out.println(a.showScore("李明", 69, 45, 92));
System.out.println(a.showScore("张华", 91, 65, 79, 82, 88));
}
}
class Cat{
//属性在定义时可以直接赋值
//Cat的全局变量
//全局变量可以不赋值，有默认值
int age = 10;
public void say{
// n 和 name就是局部变量
int n = 10;
String name = "jack"
}
}注意事项和使用细节：
a）属性和局部变量可以重名，访问时遵循就近原则；
b）在同一个作用域中，比如在同一个成员方法中，两个局部变量不能同名；
c）作用域范围不同：
全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）；
局部变量：只能在本类中对应的方法中使用；
d）修饰符不同
全局变量/属性可以加修饰符；
局部变量不可以加修饰符；
七、构造方法/构造器
基本介绍：构造方法又叫构造器，是类的一种特殊的方法，它的主要作用是完成对新对象的 初始化。
基本语法：
[修饰符] 方法名(形参列表){
方法体;
}说明：
a）构造器的修饰符可以默认；
b）构造器没有返回值；
c）方法名和类名必须一样；
d）参数列表和成员方法规则相同；
e）构造器调用系统完成。
public class Constructor01{
public static void main(String[] args){
Person p = new Person("smith", 80);
System.out.println(p.name);
System.out.println(p.age);
}
}
class Person{
String name;
int age;
//构造器没有返回值，也不能写void
//构造器的名称和类Person一样
//(String pName, int pAge) 是构造器的形参列表，规则和成员方法一样
public Person(String pName, int pAge){
System.out.println("构造器被调用,完成对象属性的初始化");
name = pName;
age = pAge;
}
}注意事项和使用细节：
a）一个类可以定义多个不同的构造器，即构造器重载；
b）构造器名和类名要相同；
c）构造器没有返回值；
d）构造器是完成对象的初始化，并不是创建对象；
e）在创建对象时，系统自动调用该类的构造方法；
f）如果没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造方 法），可以使用javap指令反编译查看；
g）一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造 器，除非显式的定义一下，即：Person(){}。
public class ConstructorDetail{
public static void main(String[] args){
Person p1 = new Person("king", 80);
Person p2 = new Person("Tom");
System.out.println(p.name);
System.out.println(p.age);
}
}
// 如果没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造方法）
class Dog{
/*
默认构造器
Dog(){}
*/
}
}
//构造器的重载
class Person{
String name;
int age;
//第一个构造器
public Person(String pName, int pAge){
name = pName;
age = pAge;
}
public Person(String pName){
name = pName;
}
}新增知识：javap指令可以反编译.class文件为可以看懂的代码。
八、this
介绍：Java虚拟机会给每个对象分配this，代表当前对象。
哪个对象调用，this就表示哪个对象！！！
this的注意事项和使用细节：
a）this关键字可以用来访问本类的属性、方法、构造器；
b）this用于区分当前类的属性和局部变量；
c）访问成员方法的语法：this.方法名(参数列表)；
d）访问构造器语法：this(参数列表)；(注意只能在构造器中使用，即只能在构造器中访 问另外一个构造器)
e）this不能在类定义的外部使用只能在类定义的方法中使用。
public class ThisDetail{
public static void main(String[] args){
// T t1 = new T();
// t1.f2();
T t2 = new T();
}
}
class T{
//访问构造器语法：this(参数列表)；(注意只能在构造器中使用，即只能在构造器中访问另外一个构造器)
//注意：如果有this(), 必须放在第一条语句
public T(){
//在这里访问public 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 f1(){
System.out.println("f1方法..");
}
public void f2(){
System.out.println("f2方法..");
//调用本类的f1
//第一种方式
f1();
//第二种方式
this.f1(); //有区别，在继承才会讲
}
}
代码自己手动敲一遍理解更深哦！
标签：Java,int,System,class,面向对象编程,JavaSE,方法,public,out From： https://blog.csdn.net/qq_63043783/article/details/136554189