Java基础编程(初级部分)

关注

原创 2024-05-04 21:32:14 850 阅读 AI 写同款· GEO 优化 ›

【Java编程进阶】Java语言基础入门篇整个 Java 编程技术栈体系十分庞大，建议初学者首先学习 Java 基础，例如语法基础，集合，IO 流，多线程，反射，注解等，再学习数据库，学会数据的持久化存储，这部分主要是 SQL 语句的学习，学会使用JDBC基础代码操作数据库等，接下来学习 JavaWeb ，主要学习 TomCat，Servlet，JSP等内容，学会使用 Java 技术解决 Web 互联网相关问题。接着学习主流的框架开发，例如 Spring ，SpringMVC，MyBatis等内容。阅读详情

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;
 } }

收录于