Java类与面向对象(创建对象成员方法形参实参递归重载可变参数作用域构造方法 this)

文章目录

面向对象快速入门
- 对象在内存中存在形式
- 类与对象
- 属性注意事项
- 类与对象内存分配机制
- 类和对象的内存分配机制
- Java创建对象的流程简单分析
成员方法快速入门
- 方法调用机制
- 为什么需要成员方法
- 返回数据类型
- 方法名
- 形参列表
- 方法体
- 方法调用细节说明
成员方法传参机制
- 基本数据类型传参机制
- 引用数据类型的传参机制
- 克隆对象
递归
- 1 斐波那契数列
- 2 猴子吃桃子
- 3 老鼠走迷宫
- 4 汉诺塔
- 5 八皇后问题
重载
可变参数
作用域
- 注意事项和细节使用
构造方法/构造器
- 注意事项和使用细节
this关键字
本章作业

张老太养了两只猫猫:一只名字叫小白，今年3岁,白色。还有一只叫小花，今年100岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫猫。

public class Test {public static void main(String[] args) {// 单独变量来解决=>不利于数据的管理// 第1只猫信息String cat1Name = "小白";int cat1Age = 3;String cat1Color = "白色";// 第2只猫信息String cat2Name = "小花";int cat2Age = 100;String cat2Color = "花色";// 用String数组呢?// 缺点 1数据类型体现不出来 2只能通过下标获取信息 3不能体现猫的行为String[] cat1 = {"小白", "13", "白色"};String[] cat2 = {"小花", "100", "花色"};// 现有技术解决的缺点分析// 1不利于数据的管理// 2效率低// --->>>>>>>>>>> 引出我们的新知识点类与对象}
}

面向对象快速入门

public class Test {public static void main(String[] args) {// cat1对象Cat cat1 = new Cat();cat1.name = "小白";cat1.age = 3;cat1.color = "白色";// 怎么使用 访问对象属性System.out.println("第一支猫信息: " + cat1.name + " " + cat1.age + " " + cat1.color);}
}// 定义一个猫类Cat ->自定义的数据类型
class Cat {// 属性String name; // 名字int age; // 年 龄String color; // 颜色
}

对象在内存中存在形式

类与对象

基本介绍
1.从概念或叫法上看:成员变量=属性= field(字段) (即成员变量是用来表示属性的，授课中，统一叫属性)
案例演示: Car(name,price,color)

2.属性是类的一个组成部分，一般是基本数据类型，也可是引用类型(对象，数组)。比如我们前面定义猫类的int age就是属性

class Car {// 属性String name; // 属性 成员变量 字段 fieldint price;String color;String[] master;// 属性可以是基本数据类型,也可以是引用类型(对象,数组)
}

属性注意事项

1)属性的定义语法同变量，示例:访问修饰符属性类型属性名;
这里简单的介绍访问修饰符:控制属性的访问范围
有四种访问修饰符public, protected,默认，private ,后面详细介绍

2)属性的定义类型可以为任意类型，包含基本类型或引用类型

3)属性如果不赋值，有默认值，规则和数组一致。

类与对象内存分配机制

public class Test {public static void main(String[] args) {Person p1 = new Person();p1.age = 10;p1.name = "小明";Person p2 = p1;System.out.println(p2.age);}
}class Person {// 属性String name; // 属性 成员变量 字段 fieldint age;
}

类和对象的内存分配机制

Java内存的结构分析

1 栈: 一般存放基本数据类型(局部变量)

2 堆:存放对象(Cat cat ,数组等)

3 方法区:常量池(常量，比如字符串)，类加载信息

4 示意图[Cat (name, age, price)]

Java创建对象的流程简单分析

public class Test {public static void main(String[] args) {// 我们看看下面一段代码，会输出什么信息:Person a = new Person();a.age = 10;a.name = "小明";Person b;b = a;System.out.println(b.name);b.age = 200;b = null;System.out.println(a.age);System.out.println(b.age);}
}class Person {// 属性String name; // 属性 成员变量 字段 fieldint age;
}

小明
200
b.age抛出异常

成员方法快速入门

在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外(年龄，姓名…),我们人类还有一些行为比如:可以说话、跑步…通过学习，还可以做算术题。这时就要用成员方法才能完成。现在要求对Person类完善。

成员方法快速入门
1)添加speak成员方法,输出我是一只好人
2)添加cal01成员方法 , 可以计算从1+...+10001 +...+ 10001+...+1000的结果
3)添加cal02成员方法，该方法可以接收一个数n,计算从1+...+n1+...+n1+...+n的结果
4)添加getSum成员方法，可以计算两个数的和

public class Test {public static void main(String[] args) {// 我们看看下面一段代码，会输出什么信息:Person a = new Person();a.age = 10;a.name = "小明";a.speak();}
}class Person {// 属性String name; // 属性 成员变量 字段 fieldint age;public void speak() {System.out.println("我是个好人");}
}

方法调用机制

为什么需要成员方法

看一个需求:

int [][] map ={{0,0,1},{1,1,1},{1,1,3}};

请遍历一个数组,输出数组的各个元素值。

解决思路1,传统的方法，就是使用单个for循环，将数组输出，大家看看问题是什么?
解决思路2:定义一个类MyTools 然后写一个成员方法，调用方法实现,看看效果又如何。

成员方法的好处
提高代码的复用性
可以将实现的细节封装起来，然后供其他用户来调用即可。

返回数据类型

1.一个方法最多有一个返回值[思考，如何返回多个结果? ] [返回数组]
2.返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
3.如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值;而且要求返回值类型必须和return的值类型一致或兼容
4.如果方法是void,则方法体中可以没有return语句，或者只写return ;

方法名

遵循驼峰命名法，最好见名知义，表达出该功能的意思即可，比如得到两个数的和getSum, 开发中按照规范

形参列表

1.一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开
2.参数类型可以为任意类型，包含基本类型或引用类型
3.调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
4.方法定义时的参数称为形式参数，简称形参;方法调用时的参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致! [演示]

方法体

里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法!即:方法不能嵌套定义。

方法调用细节说明

同一个类中的方法调用:直接调用即可。
跨类中的方法A类调用B类方法:需要通过对象名调用。比如对象名.方法名(参数);
特别说明一下:跨类的方法调用和方法的访问修饰符相关，先暂时这么提一下 ,后面我们讲到访问修饰符时，还要再细说。

成员方法传参机制

基本数据类型传参机制

方法的传参机制对我们今后的编程非常重要，一定要搞的清清楚楚明明自白。我们通过案例来学习

public class Test {public static void main(String[] args) {int a = 10;int b = 20;AA aa = new AA();aa.swap(a, b);System.out.println("\n3 a和b交换后的值\na=" + a + "\tb=" + b);}
}class AA {public void swap(int a, int b) {System.out.println(" \n1 a和b交换前的值\na=" + a + "\tb=" + b);// 完成了a和b的交换int tmp = a;a = b;b = tmp;System.out.println("\n2 a和b交换后的值\na=" + a + "\tb=" + b);}
}

可是为什么实际上的传入方法的a,b没有改变呢?

基本数据类型，传递的是值(值拷贝) ，形参的任何改变不影响实参!

引用数据类型的传参机制

B类中编写一个方法test100,可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化?
B类中编写一个方法test200，可以接收一个Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变化?

public class Test {public static void main(String[] args) {B b = new B();int[] arr = {1, 2, 3};// B类中编写一个方法test100,可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化? b.test100(arr);System.out.println(arr[0]);// B类中编写一个方法test200，可以接收一个Person(age,sal)对象， 在方法中修改该对象属性，看看原来的对象是否变化?}
}class B {public void test100(int[] arr) {arr[0] = 100;}
}

引用类型传递的是地址(传递也是值，但是值是地址) ,可以通过形参影响实参!

public class Test {public static void main(String[] args) {Person p = new Person();p.name = "jack";p.age = 12;B b = new B();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.age = 888;  // 情况1// p = null; //情况2p = new Person(); //情况3p.age = 999;}
}

克隆对象

编写一个方法copyPerson, 可以复制一个Person对象，返回复制的对象。克隆对象，
注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同

public class Test {public static void main(String[] args) {Person p = new Person();p.name = "jack";p.age = 12;MyTools tools = new MyTools();Person p2 = tools.copyPerson(p);// 此时p2与p属性相同,地址不同System.out.println(p2.name + " is " + p2.age);// 可以通过输出对象的hashCode看看对象是否是同一个System.out.println("p的hashCode " + p.hashCode());System.out.println("p2的hashCode " + p2.hashCode());}
}class Person {String name;int age;
}class MyTools {public Person copyPerson(Person p) {Person p2 = new Person();p2.age = p.age;p2.name = p.name;return p2;}
}

递归

1.执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
2.方法的局部变量是独立的，不会相互影响，比如n变量
3.如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.
4.递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError,死龟了:)
5.当一个方法执行完毕，或者遇到return, 就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

public class Test {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);}
}

1 斐波那契数列

1.请使用递归的方式求出斐波那契数列 1,1,2,3,5,8,13…的第n个值是多少?

public class Test {public static void main(String[] args) {T t1 = new T();System.out.println(t1.fibonacci(50));}
}class T {public long fibonacci(int n) {if (n > 2) {return fibonacci(n - 1) + fibonacci(n - 2);} else if (n == 1 || n == 2) {return 1;}return -1;}
}

2 猴子吃桃子

问题:有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个! 以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时(即还没吃)发现只有1个桃子了。问题:最初共多少个桃子?

思路分析逆推

day =10时有1个桃子
day=9时有(day10+1)∗2=4(day10+1)*2=4(day10+1)∗2=4
day=8时有(day9+1)∗2=10(day9+1)*2=10(day9+1)∗2=10

public class Test {public static void main(String[] args) {T t1 = new T();System.out.println(t1.peach(1));}
}class T {public int peach(int day) {if (day == 10) {return 1;} else if (day >= 1 && day < 10) {return 2 * (peach(day + 1) + 1);}return -1;}
}

3 老鼠走迷宫

public class Test {public static void main(String[] args) {// 先创建迷宫, 用二维数组表示// 规定map数组的值代表的含义 0可以走,1是有障碍物int[][] map = new int[8][7];// 将最上面一行和最下面一行,全部置为1for (int i = 0; i < 7; i++) {map[0][i] = 1;map[7][i] = 1;}// 将最左边和最右边也置为1for (int i = 0; i < 7; i++) {map[i][0] = 1;map[i][6] = 1;}// 还有隔板置为1map[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] + "\t");}System.out.println();}// 使用findWay给老鼠找路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] + "\t");}System.out.println();}}
}class T {// 使用递归回溯的方法找路// findWay就是专门来找迷宫的路径// 找到了就true,没找到就是false// map就是二维数组,表示迷宫// i,j就是老鼠的位置,初始化的位置为(1,1)// map数组里各个值的含义// 0表示可以走. 1表示障碍物, 2表示可以走,3表示走过但是走不通// 当map[6][5]=2就说明找到通路,就可以结束,否则就继续找// 先确实老鼠找路策略,  下-右-上-左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)) {// rightreturn true;} else if (findWay(map, i - 1, j)) {// upperreturn true;} else if (findWay(map, i, j - 1)) {// leftreturn true;} else {map[i][j] = 3;}} else {// map[i][j]=1,2,3return false;}}return false;}
}

4 汉诺塔

汉诺塔:汉诺塔(又称河内塔)问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一-次只能移动一个圆盘。

假如每秒钟移动一次，共需多长时间呢?移完这些金片需要5845.54亿年以上，太阳系的预期寿命据说也就是数百亿年。真的过了5845.54亿年，地球上的一切生命，连同梵塔、庙宇等，都早已经灰飞烟灭

public class Test {public static void main(String[] args) {Tower t = new Tower();t.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) {// 如果只有一个盘if (num == 1) {System.out.println(a + "->" + c);} else {// 如果有多个盘,可以简化成最下面和上面的所有// 1 移动上面所有的盘到b,借助cmove(num - 1, a, c, b);// 2 最下面的盘,到cSystem.out.println(a + "->" + c);// 3 再把b的所有盘移动到c,借助amove(num - 1, b, a, c);}}
}

5 八皇后问题

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯.贝瑟尔于1848年提出:在8x8格的国际象棋上摆放八个皇后，使其不能互相攻击，即:任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

1)第一个皇后先放第一行第一列
2)第二个皇后放在第二行第一列、然后判断是否OK，如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
3)继续第三个皇后，还是第一-列、第二列…直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
4)当得到一个正确解时，在栈回退到，上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
5)然后回头继续第一个皇后放第二列，后面继续循环执行1,2,3,4的步骤

说明:理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题。arr[8] = {0, 4, 7, 5, 2, 6, 1,3} //对应arr下标表示第几行，即第几个皇后，arr[i] = val, val表示第i+1i+1i+1个皇后，放在第i+1i+1i+1行的第val+1val+1val+1列