Java基础编程(初级部分)

1. 类与对象

1.1 入门

一个程序就是一个世界，有很多事物(对象[属性, 行为])
类与对象的关系示意图：

1.2 类和对象的区别和联系

1) 类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型.
2) 对象是具体的，实际的，代表一个具体事物, 即 是实例.
3) 类是对象的模板，对象是类的一个个体，对应一个实例

1.3 对象在内存中存在形式(重要的)

1.4 属性/成员变量/字段

1. 基本介绍：
从概念或叫法上看： 成员变量 = 属性 =field(字段) （即 成员变量是用来表示属性的，本文中，统一叫 属性)
2. 属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类的int age就 是属性

注意事项：
1. 属性的定义语法同变量，示例：访问修饰符属性类型属性名;
        控制属性的访问范围 有四种访问修饰符public,proctected,默认,private。
2. 属性的定义类型可以为任意类型，包含基本类型或引用类型
3. 属性如果不赋值，有默认值，规则和数组一致。具体说：
        int 0 short 0,byte 0,long 0,float 0.0,double 0.0，char \u0000， boolean false，String null。

1.5 如何创建对象

1) 先声明再创建 Cat cat ; //声明对象 cat         cat = new Cat(); //创建
2) 直接创建 Cat cat = new Cat();

1.6 如何访问属性

基本语法  对象名.属性名;
类和对象的内存分配机制 ： 

1.7 类和对象的内存分配机制

Java内存的结构分析
1) 栈：一般存放基本数据类型(局部变量)
2) 堆：存放对象(Catcat,数组等)
3) 方法区：常量池(常量，比如字符串)，类加载信息

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

Person p =new Person();
 p.name=“jack”;
 p.age=10

1) 先加载Person类信息(属性和方法信息,只会加载一次)
2) 在堆中分配空间,进行默认初始化(看规则)
3) 把地址赋给p,p就指向对象
4) 进行指定初始化， 比如 p.name=”jack” p.age=10

2. 成员方法

2.1 基本介绍

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

2.2 成员方法快速入门

 //1)添加speak成员方法,输出“我是一个好人”
 //2)添加cal01成员方法,可以计算从1+..+1000的结果
//3)添加cal02成员方法,该方法可以接收一个数n，计算从1+..+n的结果
//4)添加getSum成员方法,可以计算两个数的和
public class Method01{
 //编写一个main方法
public static void main(String[]args){
 //方法使用
//1.方法写好后，如果不去调用(使用)，不会输出
//2.先创建对象,然后调用方法即可
Person p1 = new Person();
 p1.speak();//调用方法
p1.cal01();//调用cal01方法
p1.cal02(5);//调用cal02方法，同时给n=5
 p1.cal02(10);//调用cal02方法，同时给n=10
 //调用getSum方法，同时num1=10,num2=20
//把 方法 getSum 返回的值，赋给 变量 returnRes
 int returnRes = p1.getSum(10, 20);
 System.out.println("getSum 方法返回的值=" + returnRes);
 } }


class Person {
 String name;
 int age;
 //方法(成员方法)
 //添加speak 成员方法,输出 “我是一个好人”
 //解读
//1. public 表示方法是公开
//2. void ： 表示方法没有返回值
//3. speak() : speak 是方法名， () 形参列表
//4. {} 方法体，可以写我们要执行的代码
public void speak() {
 System.out.println("我是一个好人");
 }
 //5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
//添加cal01 成员方法,可以计算从 1+..+1000的结果
public void cal01() {
 //循环完成
int res = 0;
 for(int i = 1; i <= 1000; i++) {
 res += i;
 }
 System.out.println("cal01 方法 计算结果=" + res);
 }
 //添加cal02 成员方法,该方法可以接收一个数n，计算从 1+..+n 的结果
//解读
//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
public void cal02(int n) {
 //循环完成
int res = 0;
 for(int i = 1; i <= n; i++) {
 res += i;
 }
 System.out.println("cal02 方法 计算结果=" + res);
 }
 //添加getSum 成员方法,可以计算两个数的和
//解读
//1. public 表示方法是公开的
//2. int :表示方法执行后，返回一个 int 值
//3. getSum 方法名
//4. (int num1, int num2) 形参列表，2 个形参，可以接收用户传入的两个数
//5. return res; 表示把 res 的值， 返回
public int getSum(int num1, int num2) {
int res = num1 + num2;
 return res;
 } }

2.3 方法的调用机制原理：(重要!-示意图!!!)

2.4 成员方法的定义

        访问修饰符  返回数据类型  方法名（形参列表..）{//方法体
                语句；
                return返回值;
         }

1) 形参列表：表示成员方法输入cal(int n)，getSum (int num1,int num2)
2) 返回数据类型：表示成员方法输出,void表示没有返回值
3) 方法主体：表示为了实现某一功能代码块
4) return语句不是必须的。

2.5 注意事项

 public class MethodDetail{
 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]);
 //细节:调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
byte b1=1;
 byte b2=2;
 a.getSumAndSub(b1,b2);//byte->int
 //a.getSumAndSub(1.1,1.8);//double->int(×)
 //细节:实参和形参的类型要一致或兼容、个数、顺序必须一致
//a.getSumAndSub(100);//× 个数不一致
a.f3("tom", 10); //ok
 //a.f3(100, "jack"); // 实际参数和形式参数顺序不对
} }

 class AA{
 //细节: 方法不能嵌套定义
public void f4() {
 //错误
// public void f5() {
 // }
 }
 public void f3(String str, int n) {
 }
 //1. 一个方法最多有一个返回值 [思考，如何返回多个结果 返回数组 ]
 public int[] getSumAndSub(int n1, int n2) {
 int[] resArr = new int[2]; //
 resArr[0] = n1 + n2;
resArr [1] = n1- n2;
 return resArr;
 }
 //2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
 //
 //
具体看 getSumAndSub
 //3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
 //
而且要求返回值类型必须和return的值类型一致或兼容
public double f1() {
 double d1 = 1.1 * 3;
 int n = 100;
 return n; // int->double
 //return d1; //ok? double-> int
 }
 //，最好是见名知意
public void f2() {
 //如果方法是void，则方法体中可以没有return语句，或者 只写 return;
 //提示：在实际工作中，我们的方法都是为了完成某个功能，所以方法名要有一定含义
System.out.println("hello1");
 System.out.println("hello1");
 System.out.println("hello1");
 int n = 10;
//return ;
 } }

访问修饰符 (作用是控制 方法使用的范围）：
如果不写默认访问，[有四种:public,protected, 默认,private]

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

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

案例：

publicclassMethodDetail02{
 //编写一个main方法
publicstaticvoidmain(String[]args){
 Aa=newA();
 //a.sayOk();
 a.m1();
 } }
 classA{
 //同一个类中的方法调用：直接调用即可
//
 publicvoidprint(intn){
 System.out.println("print()方法被调用n="+n);
}
 public void sayOk() { //sayOk 调用 print(直接调用即可)
 print(10);
 System.out.println("继续执行 sayOK()~~~");
 }
 //跨类中的方法A类调用B类方法：需要通过对象名调用
public void m1() {
 //创建B对象, 然后在调用方法即可
System.out.println("m1() 方法被调用");
 Bb=newB();
 b.hi();
 System.out.println("m1() 继续执行:)");
 } }
 class B {
 public void hi() {
 System.out.println("B 类中的 hi()被执行");
 } }

类定义的完善：

2.6 成员方法传参机制(非常非常重要)

2.6.1 基本数据类型的传参机制

案例：

public class MethodParameter01{
 //编写一个main方法
public static void main(String[]args){
 int a = 10;
 int b = 20;
 //创建AA对象名字obj
 AA obj=new AA();
 obj.swap(a,b);//调用swap
 System.out.println("main方法a="+a+"b="+b);//a=10b=20
 } }
class AA{
 public void swap(int a,int b){
 System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
 //完成了 a 和 b的交换
int tmp = a;
 a =b;
 b =tmp;
 System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
 } }

2.6.2 引用数据类型的传参机制

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

 public class MethodParameter02 {
 //编写一个main方法
public static void main(String[] args) {
 //测试
Bb=newB();
 // 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();
 //测试
Person p = new Person();
 p.name = "jack";
 p.age = 10;
 b.test200(p);
 //测试题, 如果 test200 执行的是 p=null,下面的结果是 10
 //测试题, 如果 test200 执行的是 p=newPerson();..., 下面输出的是10
 System.out.println("main 的 p.age=" + p.age);//10000
 } }

class Person {
 String name;
 int age;
 }
 class B {
 public void test200(Person p) {
 //p.age = 10000; //修改对象属性
//思考
p =new Person();
 p.name = "tom";
 p.age = 99;
 //思考
//p = null;
 }
 //B 类中编写一个方法test100，
//可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化
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();
 } }

结论：
        引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！

实例：
1) 编写类MyTools类，编写一个方法可以打印二维数组的数据。
2) 编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象， 注意要求得到新对象和原来的 对象是两个独立的对象，只是他们的属性相同

public class MethodExercise02 {
//编写一个main方法
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);
 //这里老师提示： 可以同 对象比较看看是否为同一个对象
System.out.println(p == p2);//false
 } }

class Person {
 String name;
 int age;
 }

 class MyTools {
//编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象，
//注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
//
 //编写方法的思路
//1.方法的返回类型Person
 //2.方法的名字copyPerson
 //3.方法的形参(Personp)
 //4.方法体,创建一个新对象，并复制属性，返回即可

publicPersoncopyPerson(Personp){
 //创建一个新的对象
Person p2 = new Person();
 p2.name=p.name;//把原来对象的名字赋给p2.name
 p2.age=p.age;//把原来对象的年龄赋给p2.age
 returnp2;
 } }

3. 方法递归

3.1 基本介绍

        递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变 得简洁。

3.2 递归举例

public class Recursion01 {
 //编写一个main方法
public static void main(String[] args) {
 Tt1 = newT();
 t1.test(4);//输出什么？ n=2 n=3 n=4
 int res = t1.factorial(5);
 System.out.println("5 的阶乘 res =" + res);
 } }
 class T {
 //分析
public void test(int n) {
 if (n > 2) {
 }
 test(n- 1);
 System.out.println("n=" + n);
 }
//factorial 阶乘
public int factorial(int n) {
 if (n == 1) {
 return 1;
 } else {
 return factorial(n- 1) * n;
 } } }

3.3 递归重要规则

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

3.4 练习

1. 请使用递归的方式求出斐波那契数1,1,2.3,5,8,13.….给你一个整数n，求出它的值是多
2. 猴子吃桃子问题:有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个!以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时(即还没吃)，发现只有1个桃子了。问题:最初共多少个桃子?
 

public class RecursionExercise01{
 //编写一个main方法
public static void main(String[]args){
 T t1= new T();
 //int n=7;
 //int res=t1.fibonacci(n);
 //if(res!=-1){
 // System.out.println("当n="+n+"对应的斐波那契数="+res);
 //}
 //
 //桃子问题
int day=0;
 int peachNum =t1.peach(day);
 if(peachNum!=-1){
 System.out.println("第"+day+"天有"+peachNum+"个桃子");
 }
}
 }
 class T {
 /*
请使用递归的方式求出斐波那契数1,1,2,3,5,8,13...给你一个整数n，求出它的值是多
思路分析
1. 当n=1 斐波那契数 是1
 2. 当n=2 斐波那契数 是1
 3. 当n>=3 斐波那契数 是前两个数的和
4. 这里就是一个递归的思路
*/
 public int fibonacci(int n) {
 if( n >= 1) {
 if( n == 1 | n == 2) {
 return 1;
 } else {
 }
 } else {
 return fibonacci(n-1) + fibonacci(n-2);
 System.out.println("要求输入的 n>=1 的整数");
 return-1;
 }
 }
/*
猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，
想再吃时（即还没吃），发现只有1个桃子了。问题：最初共多少个桃子？
思路分析 逆推
1. day = 10 时 有 1个桃子
2. day = 9 时 有 (day10+1)*2=4
 3. day = 8 时 有 (day9+1)*2=10
 4. 规律就是 前一天的桃子 =(后一天的桃子 +1)*2//就是我们的能力
5. 递归
*/
 public int peach(int day) {
 if(day == 10) {//第 10 天，只有1个桃
return 1;
 } else if ( day >= 1 && day <=9 ) {
 return (peach(day + 1) + 1) * 2;//规则，自己要想
} else {
 System.out.println("day 在 1-10");
 return -1;
 } } }

3.5 递归调用应用项目实例-汉诺塔

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

public class HanoiTower{
 //编写一个main方法
public static void main(String[]args){
 Tower tower=new Tower();
 tower.move(64, 'A', 'B', 'C');
 }
 }
 class Tower{
 //方法
//num表示要移动的个数,a,b,c分别表示A塔，B塔,C塔
public void move(intnum,chara,charb,charc){
 //如果只有一个盘num=1
if(num==1){
 System.out.println(a+"->"+c);
 }else{
 //如果有多个盘，可以看成两个,最下面的和上面的所有盘(num-1)
 //(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);
 } } }

4. 方法重载

4.1 基本介绍

java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！
重载的好处：        1) 减轻了起名的麻烦；         2) 减轻了记名的麻烦

4.2 快速入门案例

案例：类：MyCalculator 方法：calculate
1) calculate(int n1, int n2) //两个整数的和
2) calculate(int n1, double n2) //一个整数，一个 double 的和
3) calculate(double n2, int n1)//一个 double ,一个 Int 和
4) calculate(int n1, int n2,int n3)//三个 int 的和

public class OverLoad01 {
 //编写一个main方法
public static void main(String[] args) {
 // System.out.println(100);
 // System.out.println("hello,world");
 // System.out.println('h');
 // System.out.println(1.1);
 // System.out.println(true);
 //
 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 void calculate(int n1, int n2) {
 //
 //
 // }
 System.out.println("calculate(int n1, int n2) 被调用");
 int res = n1 + n2;
 //看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
// public int calculate(int a1, int a2) {
 //
 //
 // }
 System.out.println("calculate(int n1, int n2) 被调用");
 return a1 + a2;
 //一个整数，一个double的和
public double calculate(int n1, double n2) {
 return n1 + n2;
 }
 //一个double ,一个 Int 和
public double calculate(double n1, int n2) {
 System.out.println("calculate(double n1, int n2) 被调用..");
 return n1 + n2;
 }
 //三个int 的和
public int calculate(int n1, int n2,int n3) {
return n1 + n2 + n2;
 } }

4.3 注意事项

1) 方法名:必须相同
2) 形参列表:必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求)
3) 返回类型:无要求

4.4 练习题

5. 可变参数

5.1 基本概念

java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。 就可以通过可变参数实现

5.2 基本语法

        访问修饰符  返回类型  方法名 (数据类型...形参名){
        }        

5.3 快速入门案例 

看一个案例类HspMethod，方法sum【可以计算2个数的和，3个数的和，4.5，。。】

public class VarParameter01 {
 //编写一个main方法
public static void main(String[] args) {
 HspMethod m = new HspMethod();
 System.out.println(m.sum(1, 5, 100)); //106
 System.out.println(m.sum(1,19)); //20
 }
 }
 class HspMethod {
 //可以计算 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 + n3;
 return n1 + n2 + n3 + n4;
 // public int sum(int n1, int n2, int n3, int n4) {//4 个数的和
// }
 //.....
 //上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
//解读
//1.int...表示接受的是可变参数，类型是int,即可以接收多个int(0-多)
 //2.使用可变参数时，可以当做数组来使用即nums可以当做数组
//3.遍历nums求和即可
publicintsum(int...nums){
 //System.out.println("接收的参数个数="+nums.length);
 int res=0;
 for(inti=0;i<nums.length;i++){
 res += nums[i];
 }
 return res;
 } }

5.4 注意事项

1) 可变参数的实参可以为0个或任意多个。
2) 可变参数的实参可以为数组。
3) 可变参数的本质就是数组.
4) 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5) 一个形参列表中只能出现一个可变参数
代码：

public class VarParameterDetail{
 //编写一个main方法
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);
 }
 //细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public void f2(String str, double... nums) {
 }
 //细节: 一个形参列表中只能出现一个可变参数
//下面的写法是错的.
 // public void f3(int... nums1, double... nums2) {
 // }
 }

6. 作用域

6.1 基本使用

1. 在java编程中，主要的变量就是属性(成员变量)和局部变量。
2. 我们说的局部变量一般是指在成员方法中定义的变量。
3. java中作用域的分类
全局变量: 也就是属性，作用域为整个类体Cat类:cry eat等方法使用属性
局部变量: 也就是除了属性之外的其他变量，作用域为定义它的代码块中!
4. 全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。
代码：
 

publicclassVarScope{
 //编写一个main方法
publicstaticvoidmain(String[]args){
 } }

class Cat {
 //全局变量：也就是属性，作用域为整个类体 Cat类：cryeat 等方法使用属性
//属性在定义时，可以直接赋值
int age = 10; //指定的值是 10
 //全局变量(属性)可以不赋值，直接使用，因为有默认值，
double weight; //默认值是 0.0
 public void hi() {
 //局部变量必须赋值后，才能使用，因为没有默认值
int num = 1;
 String address = "北京的猫";
 System.out.println("num=" + num);
 System.out.println("address=" + address);
 System.out.println("weight=" + weight);//属性
}
 public void cry() {
 //1. 局部变量一般是指在成员方法中定义的变量
//2. n 和 name 就是局部变量
int n = 10;
 //3. n 和 name 的作用域在 cry方法中
String name = "jack";
 System.out.println("在 cry 中使用属性 age=" + age);
 }

public void eat() {
 System.out.println("在 eat 中使用属性 age=" + age);
 //System.out.println("在 eat 中使用 cry 的变量 name=" + name);//错误
} }

6.2 注意事项

1. 属性和局部变量可以重名，访问时遵循就近原则。
2. 在同一个作用域中，比如在同一个成员方法中,两个局部变量，不能重名。
3. 属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量,生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
4. 作用域范围不同
全局变量/属性: 可以被本类使用，或其他类使用(通过对象调用)
局部变量: 只能在本类中对应的方法中使用
5. 修饰符不同
全局变量/属性 可以加修饰符
局部变量 不可以加修饰符
代码：
 

public class VarScopeDetail {
//编写一个main方法
public static void main(String[] args) {
 Person p1 = new Person();
 /*
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量，生命周期较短，伴随着它的代码块的执行而创建，
伴随着代码块的结束而销毁。即在一次方法调用过程中
*/
 //p1.say();//当执行 say 方法时，say 方法的局部变量比如name,会创建，当say执行完毕后
//name 局部变量就销毁,但是属性(全局变量)仍然可以使用
//
 Tt1 = newT();
 t1.test(); //第 1 种跨类访问对象属性的方式
t1.test2(p1);//第 2 种跨类访问对象属性的方式
} }

class T {
 //全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
 public void test() {
 Person p1 = new Person();
 System.out.println(p1.name);//jack
 }

public void test2(Person p) {
 System.out.println(p.name);//jack
 } }

class Person {
 //细节: 属性可以加修饰符(publicprotected private..)
 //
局部变量不能加修饰符
public int age = 20;
 String name = "jack";
 public void say() {
 //细节 属性和局部变量可以重名，访问时遵循就近原则
String name = "king";
 System.out.println("say() name=" + name);
 }
 public void hi() {
 String address = "北京";
 //String address = "上海";//错误,重复定义变量
String name = "zak";//可以
} }

7. 构造方法/构造器

7.1 基本语法

        [修饰符]   方法名 (形参列表) {
                方法体;
         }
1) 构造器的修饰符可以默认， 也可以是public protected private
2) 构造器没有返回值
3) 方法名 和类名字必须一样
4) 参数列表 和 成员方法一样的规则 5) 构造器的调用, 由系统完成

7.2 基本介绍

        构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
1)  方法名和类名相同
2)  没有返回值
3)  在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

7.3 快速入门

        现在我们就用构造方法来完成刚才提出的问题:在创建人类的对象时，就直接指定这个对象的年龄和姓名

public class Constructor01 {
/编写一个main方法
public static void main(String[] args) {
 //当我们new 一个对象时，直接通过构造器指定名字和年龄
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;
 //构造器
//解读
//1. 构造器没有返回值, 也不能写void
 //2. 构造器的名称和类Person一样
//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
public Person(String pName, int pAge) {
 System.out.println("构造器被调用~~ 完成对象的属性初始化");
 name = pName;
 age = pAge;
 }}

7.4 注意事项

1. 一个类可以定义多个不同的构造器，即构造器重载
比如:我们可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名,不需要指定年龄
2. 构造器名和类名要相同
3. 构造器没有返回值
4. 构造器是完成对象的初始化.并不是创建对象
5. 在创建对象时,系统自动的调用该类的构造方法
6. 如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如Dog( ){ }, 使用javap指令反编译看看
7. 一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下,即:Dog( ){ } 写(这点很重要)
 

public class ConstructorDetail{
 //编写一个main方法
public static void main(String[]args){
 Person p1 = new Person("king",40);//第1个构造器
Person p2 = new Person("tom");//第2个构造器
Dog dog1 = new Dog();//使用的是默认的无参构造器
} }

 class Dog {
 //如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
 //使用javap 指令 反编译看看
/*
默认构造器
Dog() {
 }  */
 //一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
//除非显式的定义一下,即: Dog(){} 写 (这点很重要)
 //
 public Dog(String dName) {
 //...
 }
 Dog() { //显式的定义一下 无参构造器
} }

 class Person {
 String name;
 int age;//默认 0
 //第 1 个构造器
publicPerson(StringpName,intpAge){
 name=pName;
 age=pAge;
 }
 //第2个构造器,只指定人名，不需要指定年龄
publicPerson(StringpName){
 name = pName;
 } }

7.5 课堂练习题

在前面定义的Person类中添加两个构造器：
第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
第二个带pName和pAge两个参数的构造器：使得每次创建Person对象的同时初始化对象的age属性值和name属性值。 分别使用不同的构造器，创建对象.

public class ConstructorExercise{
 //编写一个main方法
public static void main(String[]args){
 Person p1 = new Person();//无参构造器
//下面输出name=null,age=18
System.out.println("p1 的信息 name=" + p1.name + " age=" + p1.age);
 Person p2 = new Person("scott", 50);
 //下面输出 name=scott, age = 50
 System.out.println("p2 的信息 name=" + p2.name + " age=" + p2.age);
 } }
 /**
 * 在前面定义的Person类中添加两个构造器:
 * 第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
 * 第二个带pName和pAge两个参数的构造器：
* 使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
* 分别使用不同的构造器，创建对象.
 */
 class Person {
 String name;//默认值 null
 int age;//默认 0
 public Person() {
 //第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
 age = 18;//
 }
 //第二个带pName和pAge两个参数的构造器
public Person(String pName, int pAge) {
name = pName;
 age = pAge;
 } }

8. 对象创建的流程分析

案例：

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(是对象名,也可以理解成是对象的引用)

9. this 关键字

9.1 前提案例

代码:

 public class This01 {
 //编写一个main方法
public static void main(String[] args) {
 Dog dog1 = new Dog("大壮", 3);
 System.out.println("dog1 的 hashcode=" + dog1.hashCode());
 //dog1 调用了 info()方法
dog1.info();
 System.out.println("============");
 Dog dog2 = new Dog("大黄", 2);
 System.out.println("dog2 的 hashcode=" + dog2.hashCode());
 dog2.info();
 }}

class Dog{ //类
String name;
 int age;
 // public Dog(String dName, int dAge){//构造器
//name = dName;
// age = dAge;
 // }
 //如果我们构造器的形参，能够直接写成属性名，就更好了
//但是出现了一个问题，根据变量的作用域原则
//构造器的name 是局部变量，而不是属性
//构造器的age 是局部变量，而不是属性
//==>引出this关键字来解决
publicDog(Stringname,int age){//构造器
//this.name就是当前对象的属性name
 this.name=name;
 //this.age就是当前对象的属性age
 this.age=age;
 System.out.println("this.hashCode="+this.hashCode());
 }
 public void info(){//成员方法,输出属性x信息
System.out.println("this.hashCode="+this.hashCode());
 System.out.println(name+"\t"+age+"\t");
 } }

9.2 深入理解this

9.3 this 的注意事项

1) this 关键字可以用来访问本类的属性、方法、构造器
2) this 用于区分当前类的属性和局部变量
3) 访问成员方法的语法：this.方法名(参数列表);
4) 访问构造器语法：this(参数列表);注意只能在构造器中使用(即只能在构造器中访问另外一个构造器,必须放在第一 条语句)
5) this不能在类定义的外部使用，只能在类定义的方法中使用。

9.4 this的案例

        定义Person类，里面有name、age属性，并提供compareTo比较方法，用于判断是否和另一个人相等，提供测试类TestPerson 用于测试,名字和年龄完全一样，就返回true,否则返回false
代码：

publicclassTestPerson{
 //编写一个main方法
publicstaticvoidmain(String[]args){
 Personp1=newPerson("mary",20);
 Personp2=newPerson("mary",20);
 System.out.println("p1和p2比较的结果="+p1.compareTo(p2));
 }}

 /*
定义Person类，里面有name、age属性，并提供compareTo比较方法，
用于判断是否和另一个人相等，提供测试类TestPerson用于测试,
名字和年龄完全一样，就返回true,否则返回false
*/

 classPerson{
 Stringname;
 intage;
 //构造器
publicPerson(Stringname,intage){
 this.name=name;
 this.age=age;
 }
 //compareTo比较方法
publicbooleancompareTo(Personp){
 //名字和年龄完全一样
//if(this.name.equals(p.name)&&this.age==p.age){
 // returntrue;
 //}else{
 // returnfalse;
 //}
 returnthis.name.equals(p.name)&&this.age==p.age;
 } }