194，对象内存布局
基本数据类型放在堆里面，字符串类型放在方法区。
栈：一般存放基本数据类型（局部变量）
堆：存放对象（Cat cat，数组等）
方法区：常量池（常量，比如字符串），类加载信息
196，属性注意细节
1，属性可以是基本数据类型，也可以是引用类型（对象，数组）
2，属性的定义语法同变量，示例：访问修饰符 属性类型 属性名；这里简单介绍访问修饰符：控制属性的访问范围。有四种访问修饰符 public，protected，默认，private。
3，属性如果不赋值，有默认值，规则和数组一致。具体说：int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000，boolean false，String null。
public class test1{
public static void main(String[] args){
//创建Person对象
//p1 是对象名（对象引用）
Person p1 = new Person();//new Person() 创建的对象空间（数据）才是真正的对象
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;
String isPass;
}运行结果：
198，对象分配机制
引用赋值，即地址赋值
199，对象创建过程
1，先加载Person类信息（属性和方法信息，只会加载一次）
2，在堆中分配空间，进行默认初始化（看规则）
3，把地址赋给 p ，p 就指向对象 Person p = new Person()
4，进行指定初始化，比如 p.name = "jack"
206，方法使用细节
1，一个方法最多有一个返回值 [思考，如何返回多个结果，返回数组]
2，返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）
public class test1{
public static void main(String[] args){
AA a = new AA();
int[] res = a.getSumAndSub(1,2);//用一个数组接收
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;
}
}运行结果：
3，如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值（值为常量或表达式）；而且要求返回值类型必须和 return 的值类型一致或兼容（会发生自动类型转换）
4，如果方法是 void ，则方法体中可以没有 return 语句，或者只写 return；
5，接207；一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开
6，调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
7，方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参，实参和形参的类型要一致或兼容，个数，顺序必须一致
8，方法体里面写完功能的具体的语句，可以为输入，输出，变量，运算，分支，循环，方法调用，但里面不能再定义方法！即：方法不能嵌套定义。
9，同一个类中的方法调用：直接调用即可。（我们想在A类里的一个方法里去调用A类里的另一个方法，直接调用即可）
public class test1{
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(直接调用即可）
{
print(10);
System.out.println("继续执行sayOk");
}
}运行结果：
10，跨类中的方法A类调用B类方法：需要通过对象名调用。（我们想在A类的一个方法里调用B类的一个方法，需要在A类的这个方法里创建B类的对象，再用B类的对象调用B类的一个方法）。
public class test1{
public static void main(String[] args){
A a = new A();
a.m1();
}
}
class A{
public void m1()
{
System.out.println("m1() 方法被调用");
B b = new B();//创建B对象
b.hi();
System.out.println("m1() 方法继续执行");
}
}
class B{
public void hi()
{
System.out.println("B类中的 hi() 被执行");
}
}运行结果：
11，特别说明一下：跨类的方法调用和方法的访问修饰符相关，后面会细说。
213，克隆对象
编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。克隆对象，注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同。
public class test1{
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);
}
}
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.name
p2.age = p.age;//把原来对象的年龄赋给p2.age
return p2;
}
}运行结果：
218，递归执行机制
1，执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
2，方法的局部变量是独立的，不会相互影响，比如n变量
3，如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据
4，递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError
5,当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
220，猴子吃桃
有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到了第10天时，想再吃时（即还没吃完），发现只有1个桃子了。问题：最初共多少个桃子？
（已知第10天只剩1个桃子，猴子每天都吃其中的一半，并多吃一个。假设第9天有 x 个桃子，第 10天有 y 个桃子，(x / 2) - 1 = y，x = (y + 1) * 2）
思路：逆推
1，day = 10 时，有 1 个桃子
2，day = 9 时，有 （day10 + 1）* 2 = 4
3，day = 8 时，有 （day9 + 1）* 2 = 10
4，规律就是 前一天的桃子 = （后一天的桃子 + 1）* 2
5，递归
public class test1{
public static void main(String[] args){
T t = new T();
int day = 1;
int peachNum = t.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.println("day在1-10");
return -1;
}
}
}运行结果：
221，老鼠出迷宫
思路：
1，先创建迷宫，用二维数组表示 int[][] map = new int[8][7]
2，先规定map 数组的元素值：0 表示可以走；1 表示障碍物
3，将最上面的一行和最下面的一行，全部设置为1
4，将最右面的一列和最左面的一列，全部设置为1
使用递归回溯的思想来解决老鼠出迷宫
1，findWay方法就是专门来找出迷宫的路径
2，如果找到，就返回 true，否则返回 false
3，map 就是二维数组，即表示迷宫
4，i，j 就是老鼠的位置，初始化的位置为（1,1）
5，因为我们是递归的找路，所以先规定 map 数组的各个值的含义：0 表示可以走；1 表示障碍物；2 表示可以走；3 表示走过，但是走不通，是死路
6，当 map[6][5] = 2 就说明找到通路，就可以结束，否则就继续找
7，先确定老鼠找路策略：下 -> 右 -> 上 -> 左。（有不同的策略，先确定一个自己的策略）
public class test1{
public static void main(String[] args){
int[][] map = new int[8][7];//8行7列
for(int i = 0; i < 7; i++) //i 是列，
{
map[0][i] = 1;//将最上面的一行和最下面的一行，全部设置为1
map[7][i] = 1;
}
for(int i = 0; i < 8; i++)//i 是行
{
map[i][0] = 1;//将最右面的一列和最左面的一列，全部设置为1
map[i][6] = 1;
}
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给老鼠找路
T t1 = new T();
t1.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 T{
public boolean findWay(int[][] map, int i, int j)
{
//0 表示可以走，还没走；1 表示障碍物；2 表示可以走；3 表示走过，但是走不通，是死路
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 //map[i][j] = 1,2,3
{
return false;
}
}
}
}运行结果：
225，汉诺塔
思路见代码：
public class test1{
public static void main(String[] args){
T t = new T();
t.move(3, 'A', 'B', 'C');
}
}
class T{
//num 表示要移动的个数，a,b,c分别表示A塔，B塔，C塔
public void move(int num, char a, char b, char c)
{
if(num == 1)//只有一个盘子，就直接从A移到C
{
System.out.println(a + "->" + c);
}
else
{
//1，如果有多个盘，可以看成两个，最下面的和上面的所有盘(num-1)
move(num - 1,a, c, b);//先移动上面的所有的盘到 b，借助 c，借助是指我们不能把上面的所有盘整体移过去，需要借助c
System.out.println(a + "->" + c); //3，把最下面的这个盘，移动到 c。
//4，再把 b 塔的所有盘，移动到 c，借助 a
move(num - 1, b, a, c);//把B塔的盘移动也当成两个盘在移动，和上面的 1 同理
}
}
}运行结果：
229，重载使用细节
1，方法名：必须相同
2，形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）
3，返回类型：无要求
233，可变参数使用
概念：java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现。
基本语法： 访问修饰符 返回类型 方法名（数据类型... 形参名）{}
public class test1{
public static void main(String[] args){
HspMethods m = new HspMethods();
System.out.println(m.sum(1,2,3,4));
}
}
class HspMethods{
//可以计算 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;
// }
//上面的两个方法名称相同，功能相同，参数个数不同 -> 使用可变参数优化
//1， int... 表示接受的是可变参数，类型是int，即可以接收多个int（0-多）
//2， 使用可变参数是，可以当做数组来使用，即 nums 可以当做数组
public int sum(int... nums)
{
int res = 0;
for(int i = 0; i < nums.length; i++)
{
res += nums[i];
}
return res;
}
}运行结果：
234，可变参数细节
1，可变参数的实参可以为 0 个或任意多个（见 233 代码）
2，可变参数的实参可以为数组
public class test1{
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);
}
}运行结果：
3，可变参数的本质就是数组
4，可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后（否则报错）
public void f2(String str, double... nums){}5，一个形参列表中只能出现一个可变参数
235，可变参数练习
问题：有三个方法，分别实现返回姓名和两门课成绩（总分），返回姓名和三门课成绩（总分），返回姓名和五门课成绩（总分）。封装成一个可变参数的方法。类名 HspMethod 方法名 showScore
分析：两门课，三门课，五门课成绩，理解为一个可以接收多个double 类型的可变参数，问题要求返回姓名和三门课成绩（总分），所以方法的返回类型是 String，形参(String, double... )
public class test1{
public static void main(String[] args){
HspMethod t1 = new HspMethod();
System.out.println(t1.showScore("milan", 60,80));
System.out.println(t1.showScore("jack", 60,80,80));
System.out.println(t1.showScore("lucy", 60,80,80,90,80));
}
}
class HspMethod{
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;
}
}运行结果：
236，作用域基本使用
1，在java编程中，主要的变量就是属性（成员变量）和局部变量
2，我们说的局部变量一般是指在成员方法中定义的变量
3，java 中作用域的分类。
全局变量：也就是属性，作用域为整个类体；
局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中！
4，全局变量（属性）可以不赋值，直接使用，因为有默认值，局部变量必须赋值后才能使用，因为没有默认值。
237，作用域使用细节
1，属性和局部变量可以重名，访问时遵循就近原则。
public class test1{
public static void main(String[] args){
Person p1 = new Person();
p1.say();
}
}
class Person{
String name = "jack";
public void say()
{
String name = "king";
System.out.println("say() name = " + name);
}
}运行结果：
2，在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名
3，属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
4，全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）。 局部变量：只能在本类中对应的方法中使用
public class test1{
public static void main(String[] args){
Person p1 = new Person();
T t1 = new T();
t1.test();//第1种跨类访问对象属性的方式
t1.test(p1);//第2种跨类访问对象属性的方式
}
}
class T{
public void test()
{
Person p1 = new Person();//Person类中的全局变量name，可以在T类中使用，通过对象调用
System.out.println(p1.name);//jack
}
public void test(Person p)
{
System.out.println(p.name);//jack
}
}
class Person{
String name = "jack";
}运行结果：
5，修饰符不同 ：全局变量/属性可以加修饰符；局部变量不可以加修饰符
239，构造器基本介绍
构造方法又叫构造器，是类的一种特殊方法，它的主要作用是完成对新对象的初始化
基本语法： 修饰符 方法名(形参列表) { 方法体 }
说明：1，构造器的修饰符可以默认，也可以是public protected private
2，构造器没有返回值
3，方法名和类名字必须一样
4，参数列表 和 成员方法 一样的规则
5，在创建对象时，系统会自动调用该类的构造器完成对对象的初始化
public class test1{
public static void main(String[] args){
Person p1 = new Person("smith", 80);//当我们new 一个对象时，直接通过构造器指定名字和年龄
System.out.println("p1的信息如下");
System.out.println("p1对象name = " + p1.name);
System.out.println("p1对象age = " + p1.age);
}
}
class Person{
String name;
int age;
public Person(String pName, int pAge)
{
System.out.println("构造器被调用~~ 完成对象的属性初始化");
name = pName;
age = pAge;
}
}运行结果：
6，一个类可以定义多个不同的构造器，即构造器重载
7，如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造器），比如 Dog() { }
8，一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显示的定义一下，即：Dog() {}
244，对象创建的流程分析
看一个案例
class Person{//类Person
int age = 90;
String name;
Person(String n, int a)//构造器
{
name = n;//给属性赋值
age = a;
}
}
Person p = new Person("小倩",20);流程分析（面试题）
1，加载Person类信息（Person.class），只会加载一次
2，在堆中分配空间（地址）
3，完成对象初始化
3.1，默认初始化 age = 0，name = null 3.2，显示初始化 age = 90，name = null 3.3，构造器的初始化 age = 20，name = 小倩
4，在对象在堆中的地址，返回给 p（p是对象名，也可以理解成是对象的引用）
249，this 使用细节
1，哪个对象调用，this就代表哪个对象
2，this 关键字可以用来访问本类的属性，方法，构造器
3，this用于区分当前类的属性和局部变量
4，访问成员方法的语法：this.方法名(参数列表)
public class test1{
public static void main(String[] args){
T t = new T();
t.f2();
}
}
class T{
public void f1()
{
System.out.println("f1() 方法..");
}
public void f2()
{
System.out.println("f2() 方法..");
//调用本类的 f1
f1();//第一种方式
this.f1();//第二种方式 this.方法名（参数列表）
}
}运行结果：
5，访问构造器语法：this(参数列表)；注意只能在构造器中使用（即只能在构造器中访问另外一个构造器，必须放置第一条语句）
public class test1{
public static void main(String[] args){
T t = new T();
}
}
class T{
public T()
{
this("jack", 100);//这里去访问T(String name, int age) 构造器
System.out.println("T() 构造器");
}
public T(String name, int age)
{
System.out.println("T(String name, int age) 构造器");
}
}运行结果：
6，this不能在类定义的外部使用，只能在类定义的方法中使用
250，this课堂练习
问题：定义Person类，里面有name，age属性，并提供compareTo比较方法，用于判断是否和另一个人相等，提供测试类TestPerson 用于测试，名字和年龄完全一样，就返回true，否则返回false
public class TestPerson{
public static void main(String[] args){
Person p1 = new Person("mary", 20);
Person p2 = new Person("smith", 30);
System.out.println(p1.compareTo(p2));
}
}
class Person{
String name;
int age;
public Person(String name, int age)
{
this.name = name;
this.age = age;
}
public boolean compareTo(Person p)//和另一个人的姓名年龄比较，所以形参是Person对象，还要知道这个对象的信息（通过构造器）
{
return this.name.equals(p.name) && this.age == p.age;
}
}运行结果：
253，本章作业03
问题：编写类Book，定义方法updatePrice，实现更改某本书的价格，具体：如果价格>150，则更改为150，如果价格>100，更改为100，否则不变。
分析：更改某本书的价格，可以理解为更改一个对象的价格属性，需要先用构造器完成对这个对象的价格的初始化，再到方法中进行更改。
public class test1{
public static void main(String[] args){
Book book = new Book("小王子", 120);
book.info();
book.updatePrice();
book.info();
}
}
class Book
{
String name;
double price;
public Book(String name, double price)
{
this.name = name;
this.price = price;
}
public void updatePrice()
{ //如果方法中，没有 price 局部变量，this.price 等价 price
if(price > 100)
{
price = 100;
}else if(price > 150)
{
price = 150;
}
}
public void info()
{
System.out.println("书名 = " + this.name + " 价格 = " + this.price);
}
}运行结果：
260，本章作业10
public class test1 {
public static void main(String[] args) {
Circle c = new Circle();
PassObject po = new PassObject();
po.printAreas(c,5);
}
}
class Circle
{
double radius;
public Circle()//在第2问我们没有办法确认半径值，在for循环那里才知道半径值是变化的,所以要重写默认构造器
{
}
public Circle(double radius)//第1问要用到这个
{
this.radius = radius;
}
public double findArea()//返回面积
{
return radius * radius * Math.PI;
}
public void setRadius(double radius)//添加方法 setRadius,修改对象的半径值
{
this.radius = radius;
}
}
class PassObject
{
public void printAreas(Circle c, int times)
{
System.out.println("radius\tarea");
for(int i = 1; i <= times; i++)
{
c.setRadius(i);//可以用到Circle对象，并能把i传进去，如果每次都new 一个新对象（用构造器），就不划算
System.out.println(i + "\t" + c.findArea());
}
}
}运行结果：
