第二章Java基础二--对象与类、封装、构造方法

已于 2024-04-24 20:55:32 修改
阅读量3k 收藏 49
点赞数 48
分类专栏： Java编程基础 文章标签： java 开发语言
于 2022-03-14 18:47:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lizyviking_/article/details/123476394
版权

在这里插入图片描述

  戳我跳到个人主页

  本人码云（建议pc端打开，手机可能会出现字体过小问题。)
  本人会不定期在码云上更新一些算法或数据结构的基础程序，后期也会学习进阶程序，也会更新大厂的面试题。
  如果您有好的建议和想法，欢迎在本人码云相应代码评论区评论哦。希望大家都能在编程这条路上越走越远。也祝看到这篇博客的人，能真正搞懂这方面知识，当然，若有错误，请提出改正，谢谢大家啦。
  本人后续会在这里更新操作系统和计组的笔记，敬请期待！
  有赞必回，评论必回，顺着网线回访！

对象与类、封装、构造方法

1.Java类1

（1）引入

/*
 （一）面向对象与面向过程
   –面向过程：当需要实现一个功能时，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

   –面向对象：当需要实现一个功能时，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。
*/
在程序世界中，有很多的编程范式（思想）
C —— 面向过程的编程语言
Java / C++ ——面向对象的编程语言

行为一定是某个对象发出，然后作用于另一个对象或某些对象。

package packone;

import java.util.Arrays;
public class Face01
{
	public static void main(String[] args)
	{
		int [] array = { 10, 20, 30, 40, 50 };
		//要求打印格式为：[10，20，30，40，50]
		//使用面向过程：
		System.out.print("[");
		for( int i = 0; i < array.length; i ++ )
		{
			if ( i == array.length - 1 ){
				System.out.println( array[i] + "]" );
			}
			else
				System.out.print( array[i] + "，" );
		}
		System.out.println("=================");
		//使用面向对象
		//找一个JDK给我们提供好的Arrays类，
		//其中有一个toString方法，直接得到想要的格式。
		System.out.print(Arrays.toString(array));
	}
}

在这里插入图片描述

（2）定义

 （二）面向对象三大特征
封装 继承 多态
~所有面向对象的编程语言都有这三大特征。
~C++半面向对象，Java纯面向对象。

 （三）类和对象
我们把具有相同属性和行为的一类对象抽象为类。

类中定义了所有该类对象所共同具备的属性和方法
人类的属性：姓名，年龄，性别，身高，体重等等；
手机的属性：品牌String brand，价格double price，颜色String color等等

使用类来描述这类对象的特性：

  • 类 —— 抽象概念，人类、猫类、犬类 ==> 无法具体到某个实体
  • 对象 —— 某个类的一个实体，当有对象之后，这些属性就有了属性值，这些行为有就也了相应的意义。

我和彭于晏有啥区别？我俩都是人类的对象
共性：我俩都有五官，他有的东西，我也有，其他任何的人类对象都有；（这个就相当于我们都具有什么变量）
区别：我俩的属性值不同，我比他年轻，比他高（相当于变量的具体的值）

在java：一切都围绕对象进行。找对象，建对象，用对象。

类是描述某一些对象的统称，一个对象就是这个类的一个实例而已。

这一类对象所具备的共同属性和 方法都在类中定义。
称为：成员变量和成员方法

类与对象的关系

  • 类是对一类事物的描述，是抽象的。
  • 对象是一类事物的实例，是具象的。
  • 类是对象的模板，对象是类的实体。

 （四）类的定义
定义类：就是定义类的成员，包括变量和方法。

成员变量：在类中，方法外。
成员方法：去掉static。

创建类的语法：
class 类名 
{
	//field （实例变量，成员变量）
	//行为 （实力行为，成员方法）
}

例：

class Person
{
	//成员变量
	String name;
	int age;	//年龄
	String sex;//性别
	
	//成员方法
	void eat(){}	//吃饭
	void sleep(){}	//睡觉
}

在Java中一个源文件（*.java）只可以存在一个主类。

类的名字和文件名一致，并且包含main函数的类，叫做主类。

public class Test
{
	public static void main(String[] args)
	{
		Person per = new Person();
		per.name = "lzy";
		per.age = 19;
	
		per.eat("葡萄");
		per.print();
	
	}
}

class Person
{
	String name;
	int age;
	String sex;
	
	void eat(String food)
	{
		System.out.prinln( name + "正在吃 " + food );
	}
	
	
	void print()
	{
		System.out.println( "我叫" + name + ",年龄为:" + age );
	}
	
}

（3）对象的创建及使用

1.类的命名使用有意义的大驼峰命名法

class PersonalPage

2.类中定义的成员变量都有默认值

3.使用
导包：
也就是指出需要使用的类，在什么位置。
import 包名称.类名称；

对于和当前类属于同一个包的情况，可以省略导包语句。

使用：
类名称 引用名称 = new 类名称();
Person per = new Person();

程序的运行都是从右向左

右边：new Perosn(); 这是对象、在堆中存储
左边：Person per 这是一个Person类的引用、在栈中存储
(引用：给这个对象起了一个名字)

当产生一个类的对象之后，我们就可以使用"."操作符来使用对象的属性和方法（成员变量和成员方法）

public static void main(String[] args)
{
	Person per1 = new Person();
	Person per2 = new Person();

	per.name = "lzy";
	per.age = 18;
	per.sex = "男";
	per1.print();
	per2.print();

	per2未定义、所以全部是默认值：null、0、null
}

内存图：
在这里插入图片描述
如果我写per1 = per2，会有什么变化？
此时per1不再指向0x100、而是指向0x300

成员变量：每个Person的对象都有，在堆中的每个对象所在内存区域中存储；
成员方法：在方法区中存储

成员变量也可以在类定义时赋值。

class test
{
	String name = "测试";
}

java中所有的.class文件都是引用数据类型 ！

对于引用类型、默认值为null、关于引用数据类型的特殊值 null

null 在Java中表示 “ 空引用 ” ，只有名字没有去保存任何堆内存中的地址，如果直接使用值为 null 的引用去操作 “.” 任何属性或方法，将会产生编译错误。

NullPointerException
空指针异常、这个异常、表示我调用了一个值为 null 的引用

这里指的是成员属性和成员方法
和静态无关、静态是属于类的
也即是说可以通过一个该类的空引用null、去访问静态变量和静态方法。

（4）Student.java、Phone.java

定义一个类，模拟“学生”事物。

成员变量（属性）：
姓名 String name ;
年龄 int age ;

成员方法（行为）：
吃饭 public void eat () {}
睡觉 public void sleep () {}
学习 public void study () {}

注意事项：
1、成员变量是直接定义在类当中的，在方法外边。
2、成员方法不要写static关键字。

 package packone;
 
 public class Student
 {
 	String name = "Lee";
 	int age = 21;
 	public void eat(){
 		System.out.println("吃饭喽！");
 	}
 	public void sleep(){
 		System.out.println("睡觉喽！");
 	}
 	public void study(){
 		System.out.println("学习喽！");
 	}
 }

定义一个类，模拟手机事物。

成员变量（属性）：
品牌   String brand ;
价格   double price ;
颜色   String color ;

成员方法（行为）：
打电话  public void call ( String who ) {}
群发短信 public void sendMessage () {}

package packone;

public class Phone
{
	String brand;
	double price;
	String color;
	
	public void call( String who ){
		System.out.println("给"+who+"打电话");
	}
	public void sendMessage(){
		System.out.println("群发短信");
	}
	
}

（5）Phone类练习

package packone;

public class Demo00Phone
{
	
	public static void main(String[] args)
	{
		Phone one = new Phone();
		System.out.println(one.brand);
		System.out.println(one.price);
		System.out.println(one.color);
		one.call("佐助");
		System.out.println("============");
		
		one.brand = "RedmiK20Pro";
		one.price = 2499.9;
		one.color = "鎏金红黑色";
		System.out.println(one.brand);
		System.out.println(one.price);
		System.out.println(one.color);
		one.call("雷军");
	}

}

结果 ：
在这里插入图片描述

（6）自定义类作为方法的参数

package packone;

public class Demo01Phone
{

	public static void main(String[] args)
	{
		Phone one = new Phone();
		one.brand = "苹果";
		one.price = 8388.0;
		one.color = "土豪金";
		method(one);
	}
	
	public static void method(Phone param)
	{
		System.out.println(param.brand);
		System.out.println(param.price);
		System.out.println(param.color);
	}

}

结果 ：
在这里插入图片描述

（7）自定义类作为方法返回值

package packone;

public class Demo02Phone
{
	public static void main(String[] args)
	{
		Phone two = getPhone();
		System.out.println(two.brand);
		System.out.println(two.price);
		System.out.println(two.color);
	}
	
	public static Phone getPhone()
	{
		Phone one = new Phone();
		one.brand = "苹果";
		one.price = 8388.0;
		one.color = "玫瑰金";
		return one;
	}
	
}

结果 ：
在这里插入图片描述

（8）局部变量、成员变量

一、概念
定义一个类：

public class { //成员变量 //成员方法 }

局部变量：
局部变量,也称内部变量,是指在一个函数内部或复合语句内部定义的变量。
二、区别
1、定义的位置不同【重点】
局部变量：在方法的内部；
成员变量：在方法的外部，直接写在类当中。

2、作用范围不同【重点】
局部变量：只有方法体中才可以使用，出了方法就不能使用；
成员变量：整个类都可以通用。

3、默认值不同【重点】
局部变量：没有默认值；
成员变量：有默认值。

4、内存位置

局部：位于栈；
成员：位于堆。

5、生命周期
局部：随着方法进栈而诞生，随着方法出栈而消失；
成员：随着对象创建而诞生，随着对象被垃圾回收而消失。

示例代码：

package class1;

public class test1
{
    public static void main(String[] args) {

        ttt one = new ttt();
        one.methodA();
        one.methodB( "东北虎" );

    }


}


class ttt
{
    String name;	//成员变量
    public void methodA()
    {
        int num = 20;
        //有初值的局部变量

        System.out.println( num );
        System.out.println( name );
        //未被赋初值的成员变量、会有初值 null
    }

    public void methodB( String tiger )
    {
        // tiger 这个局部变量、在方法调用时，必然会被赋值
        // 所以可以正常输出
        int age;

        System.out.println( tiger );	//编译正确
        //System.out.println( age );		//编译错误，无初值
    }
}

结果 ：
在这里插入图片描述

2.静态static关键字

（0）先介绍构造方法

类中的构造方法：
是类中一种非常特殊的方法，使用关键字new实例化对象时，实际上就是调用该类的构造方法。

构造方法的作用就是产生对象。

使用关键字new产生对象时，分为两步
1.为对象在堆中分配空间；
2.调用对象的构造方法为对象成员变量赋值。

构造方法语法规则：

1.方法名和类名完全相同
2.构造方法没有返回值声明（不是void）
3.一个类中至少有一个构造方法、如果没有写， 编译器会自动赠送一个默认的无参构造方法

当我们new一个对象时，就自动调用构造方法。
Person per = new Person();

如果我们自己定义了、则系统不再赠送.

构造方法的执行过程：

new Person();
产生了一个Person的对象
1.先在堆上开辟一块空间（大小由该类中的成员变量的属性决定）
2.调用对象的构造方法为所有成员变量赋值
（成员变量就是在构造方法中赋值的！如果不写，默认会设置为默认值）
当构造方法调用结束，该对象就初始化完成。

构造方法可以重载：

构造方法是为了类中的成员变量赋值的，此时的重载只可能是参数的个数不同。
（成员变量的类型在类定义时，就指定好了，所以重载只可能是初始化变量的个数不同）

public class Test
{
	Person.per1 = new Person();
	Person.per2 = new Person("lzy");
	Person.per3 = new Person("lzy", 18);
	//这三个对象，构造方法都已经调用完成，初始化完成
	//person.Person();不可以
	//自己调用自己的构造方法、不合理
	// JVM产生对象时调用构造方法，对象实例化结束，
	// 无法在程序中手动调用构造方法再次实例化对象！！！
}

class Person
{
	private String name;
	private int age;
	private String sex;
	
	public Person ()
	{
		System.out.println("Person的无参构造方法");
	}
	

	public Person ( String n )
	{
		//默认在第一行做这个事
		//name = null, age = 0, sex = null
		//然后再赋予你想要的值
		name = n;
		System.out.println("name = " + name );
		System.out.println("Person的一个参数的有参构造");
	}
	public Person ( String n, int a )
	{
		name = n;
		age = a;
		System.out.println("name = " + name + ", age = " + age );
		System.out.println("Person的两个参数的有参构造");
	}




}

在成员变量定义时，就赋初值，怎么看？
在这里插入图片描述
成员变量只有在产生对象时，才会在堆中分配空间
Person person = new Person();
成员变量的赋值就是在构造方法中进行的。

（1）概述（内存分析）

为何会引入static关键字呢？

很多对象的某个属性的值都是同一个值、比如中国人这个类的所有对象的country = "中国"

成员变量，所有对象都在堆中保存有自己的country属性。

假设有一天、英勇的解放军光复了日本，所有日本人的country属性值是不是都改为“中国”，如果一个对象一个对象的去修改、是不是很麻烦，所以我们需要一个所有人共有的属性值相同的属性，对于country这个值来说，他应该是很多对象共有的一个属性，使用static修饰这个属性，该属性就称为静态属性。

当一个成员变量被static修饰时，他就表示类的属性。

该类的所有对象都共享这个属性，所有对象的属性值大家都一样。

static修饰的属性在JVM的方法区中存储，所有该类对象共享该属性。

方法区：
a.类中的所有方法；
b.全局常量，静态变量。

注意：
1.只有被static修饰的常量才保存在方法区
2.对于普通的仅仅由final修饰的常量，成员常量保存在堆区，局部常量保存在栈区。（和普通的变量保存的位置没什么区别）

内存分析：
先要有Person类才能产生对象（堆中），首先将Person类加载到主类中，Person类中的所有static变量就会被加载到方法区中。

内存分析：
先在主类中加载Person类，此时，static定义的所有变量被赋予默认值为初值，并全部被加载到方法区中，因为，我们定义了一个全局常量，在这里，就另Person2.hairColor的值为black，同时，Person类的所有方法也被加载到方法区中，此时，Person的两个普通的成员变量没有初值，没有意义。
接着，通过构造方法创建了两个对象，再两次调用构造方法时，默认在构造方法第一行执行 name = null；age = 0（为成员变量赋初值）；如果需要修改他们的值，可以使用有参的构造方法，不过在有参的构造方法中，本质上是通过this();调用的无参构造方法，所以依然会执行默认值的赋值，然后再赋予你给予的值，同时、因为我们还定义了一个普通的final常量、所以这两个对象的skin属性值都会被赋予yellow。当构造方法调用结束，该对象就初始化完成。
然后就可以使用这些变量和方法了~~在这里插入图片描述注意：
当其中一个对象调用成员方法时、把那个方法从方法区加载到栈中、再进行后续操作；当其中一个对象调用成员变量或普通的final常量时，直接通过栈中引用保存的地址去堆区找需要的数据；当调用静态属性时，通过引用保存的地址先去堆去、然后再从堆区去方法区找。

（2）静态static关键字修饰成员变量

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享一个成员变量。

类名称.变量名，就可以表示这个成员变量。
也可以使用 对象名.静态变量名、但不规范！

在Java中，能否在一个方法的内部定义一个static变量？

不能！！！！！！！！！！
方法中定义的变量都是局部变量、局部变量在栈中存储，而static关键字定义的变量存储在方法区中、it’s impossible~~

final关键字和static有啥区别？

class Person
{

	final int age = 18;	
	成员常量，都在堆中存储
	static final String hairColor = "black";
	全局常量、在方法区中存储
	必须在定义时赋值！
	
	
	static String country = "中国";
	静态变量，在方法区中存储，所有的Person对象共享这个country属性
	
}

在类中定义了一个常量、我们通常都会把static和final共同使用，称为类的常量

每个Person类的对象都有age属性，它是一个成员常量，在类定义的时候就赋值了，且值为18，不能修改，这不是一个天然的共享概念吗？为啥不把它定义为static final 呢？所有Person对象共享这个属性，全局唯一。

在类中定义常量，一般都会使用全局常量
static final共同修饰。

常量的命名规则：
所有单词全部大写，单词之间使用下划线分隔
static final String STUDENT_SCHOOL = "清华大学";

总结一下：
a.static变量称为类属性，在方法区中存储，该类的所有对象共享此变量。
b.若在类中定义了常量（定义时必须赋值！），或在构造方法中赋值，一般我们使用static final共同修饰，称为全局常量。
c.要使用类属性，我们通常直接通过类名称.属性名称 不推荐使用对象来调用，不规范。
d.关于static关键字的理解（面试 / 笔试易错）
static属性（静态成员变量和静态成员方法）称为类属性，通过类名称进行访问，此时没有对象也能调用，（包含该类的 null 引用）

Person per = null;
System.out.println(Person.country);
System.out.println(per.country);
//也是可以的！因为country是静态变量，
//你只要是Person类的引用，你就能调用这个静态变量
// 你现在还没有结婚，你还没有对象，但是以后你的孩子一定是中国人！
// 可以这么理解

（3）静态static关键字修饰成员方法

static修饰方法：称为类方法 —— 或者工具方法

主方法就是一个static方法
public static void main(String[] args)

为啥主方法是一个静态方法？

主方法是一个程序的入口，如果主方法是一个成员方法，是不是得通过对象调用？
入口都没有，从哪产生对象啊~~
程序从主方法开始执行，主方法要能调用起来，必须是静态方法，直接调用，无需产生对象。

共享的变量、如country属性、设计为静态变量
哪些方法设置为静态方法呢？工具类的方法

Arrays.sort( int [] )
Arrays.copyOf()

都是Arrays提供的操作数组的方法、设计为static方法

看见static关键字、都和对象无关、直接通过类名称访问静态属性和方法。
静态和非静态之间可以相互访问吗？

从static的语义出发：静态 => 无需产生对象就能调用的方法

static：是静态、想逻辑、没有对象就能访问的属性和方法；

成员域：成员方法和成员变量必须通过对象来调用。

a.在静态方法中、只能调用静态方法或者静态属性，static家族之间可以相互调用。不能直接调用成员方法和成员变量，必须通过对象来调用。

b.在成员方法中，既可以调用成员属性、又可以调用静态方法（静态域不需要对象即可访问、更何况、此时都有了该类对象，一定可以访问静态域）

静态方法体中不能用this
原因：
this代表当前对象，通过谁调用的方法，谁就是当前对象，但是，静态与对象无关。

普通的类能否使用static关键字修饰？

static class Person{
}

类定义出来是干啥呢？要产生对象吧
如果用static定义、就不能产生对象了！
没对象我要这个类做什么？

（4）静态代码块

代码块：指的就是使用{}括起来的一段代码

根据定义的代码块的设置以及关键字的不同分为以下四种情况

普通代码块 ：定义在方法中，使用{}括起来的代码

成员代码块 ：定义在类中，使用{}括起来的代码块，也叫构造快

静态代码块 ：使用static关键字修饰的代码块
同步代码块 ：多线程synchronized讲

public static void main(String[] args)
{
	//普通代码块
	{
		int a = 10;
	}
	int a = 20;
	System.out.println( "a = " + a );
}

构造块：直接定义在类中，不加任何修饰符，优先于构造方法执行，有几个对象产生，就调用几次构造块。

class Animal
{
	private String name;
	
	{
		// 构造块
		System.out.println("Animal的构造块");
	}
	
	public Animal()
	{
		System.out.println("Animal的无参构造");
	}
	public Animal(String name)
	{
		this.name = name;
	}
}

静态代码块： 定义在类中，使用static修饰的代码块，在类加载的时候执行

class Animal
{
	static int age = 10;
	static{
		age = 100;
		System.out.println("Animal的静态代码块");
	}
}

注意：

静态代码块只在类加载时执行一次
静态代码块 优于 构造方法 执行
静态代码块 优于 主方法 执行
JVM 要执行主方法，首先得要加载主类。
主类一加载，静态块就执行了。
只有加载之后，才会有程序入口，才会运行main方法

静态块 > 构造块 > 构造方法 （构造块和构造方法、只有在创建对象时、才执行）

静态块 > 主方法

静态变量和静态块：
1.静态变量存在于方法区中、类定义的时候就会有初始值，初始值为0
这个类就被放入方法区中 => 这个类只是被定义了，还没被加载。

2.当主方法使用了 Animal ，就需要把Animal从方法区加载到内存中
类加载=> 静态代码块执行，age = 0 => 10 => 100

public class Person
{
	//静态代码块
	static {
		System.out.println("静态代码执行！");
	}	
	//无参构造方法
	public Person(){
		System.out.println("构造方法执行！")；
	}
}

（5）静态再分析

	static int a = 10;
	static
	{
		System.out.println(a);
		a = 100;
		System.out.println(a);
	}
	static
	{
		a = 300;
		System.out.println(a)；
	}
	
	public Person()
	{
		a = 22;
		System.out.println(a);
	}

	{
		a = 19;
		System.out.println(a);
	}

1.类一加载，所有静态变量都是其默认值、a = 0;
2.静态区域执行：
age = 初始值10
age = 静态块的赋值300
age = 静态块的赋值100
3.构造块执行：
age = 构造块的赋值19
4.构造方法执行：
age = 构造方法的赋值22
上述代码中、即使把构造块写在构造方法后面、也是先执行构造块。在这里插入图片描述

上述代码：就相当于这个=>

	static
	{
		int a = 10;
		System.out.println(a);
		a = 100;
		System.out.println(a);
		a = 300;
		System.out.println(a)；
	}
	
	
	public Person()
	{
		a = 22;
		System.out.println(a);
	}

	{
		a = 19;
		System.out.println(a);
	}

3.Java类2

（1）private关键字

封装性在Java中的体现

——封装就是将一些细节信息隐藏起来，对于外界不可见

关键字 private 就是一种封装

Person类：

package packone;
/*
问题描述：定义Person的年龄时，无法检验数字是否有意义，
比如0岁或负岁。
解决：用private关键字将需要保护的成员变量进行修饰。

	一旦使用prinvate关键字，本类中可以直接访问
	一旦出了本类，不可直接访问。
*/
public class Person
{
	String name;		//姓名
	private int age;	//年龄
	
	public void show(){
		System.out.println("我叫："+ name + "，年龄："+ age );
	}
}

应用类

package packone;

public class Demo01Person
{
	public static void main(String[] args)
	{
		Person me = new Person();
		me.show();
		me.name = "彭于晏";
		me.age = 18;		//报错！！！
		me.show();
	}

}

思考：如何才能让我们既可以保护需要被保护的变量，又可以能简洁的访问到它？

关于权限修饰符：

在 Java 中，所谓的权限修饰符，指的是，你修饰的属性、方法、类，到底可见的范围有多大，可见的范围从小到大依次为：
private < default( 不写 ) < protected < public

1.public 公有的、公开的
被public修饰的东西，在当前程序（项目中）都是可见的，都是可以使用的
2.private 私有的
被private修饰的属性和方法，只在当前类的内部可见，出了类的{}，对外部就完全隐藏了，外部不知道有其存在。

想在类的外部去使用这些私有属性，需要使用类提供的Getter()和Setter()方法

到底哪些属性需要提供Getter，让外部可见
哪些属性需要提供Setter，让外部可以修改
都要根据这个属性的特征来决定~~

例：

	//卡号	
   private int cardNum; 只能读取、不能修改
   //余额
   private double sal; 只能读取
   //密码
   private String password; 只能读也可以改
   //这三个属性、只在Bank类内部可见

在 idea 中、alt + insert 快速生成 Getter / Setter 方法

所以将Person类稍作修改：

package packone;
/*
问题描述：定义Person的年龄时，无法检验数字是否有意义，
比如0岁或负岁。
解决：用private关键字将需要保护的成员变量进行修饰。

	一旦使用prinvate关键字，本类中可以直接访问
	一旦出了本类，不可直接访问。

	间接访问private成员变量，定义Getter和Setter方法。
	对于Getter来说，不能有参数，返回值类型和成员变量对应；
	对于Setter来说，不能有返回值，参数类型和成员变量对应。
*/
public class Person
{
	String name;		//姓名
	private int age;	//年龄
	
	public void show(){
		System.out.println("我叫："+ name + "，年龄："+ age );
	}

	//这个成员方法，专门用于设置age的值
	public void setAge(int num){
		if ( num < 100 && num >= 0 )
			age = num;
		else
			System.out.println("数据不合理");
	}
	//这个成员方法，专门用于获取age的值
	public int getAge(){
		return age;
	}
	
}

应用：

package packone;

public class Demo01Person
{	
	public static void main(String[] args)
	{
		//java封装性——private关键字
		Person me = new Person();
		me.show();
		me.name = "彭于晏";
		me.setAge(-20);
		me.show();		
		me.setAge(70);
		me.show();
	}	
}

结果 ：
在这里插入图片描述

补充：对于 boolean 型的成员变量，Getter 方法一定要写成 isXXX 的形式，Setter 方法形式不变。

private能否修饰一个类呢？

private不能修饰外部类
-> 类定义出来是不是就得产生对象，让外部使用，private修饰一个类，定义之后，外部都不知道，还怎么用？

（2）this关键字

当方法的局部变量和类的成员变量重名时，根据 “就近原则”，优先使用局部变量。

如果需要访问本类中的成员变量，需要使用格式：
this.成员变量名

“ 通过谁调用的方法，谁就是 this ”

package packtwo;
public class Person
{
	String name;	//我自己的名字
	//this.name是成员变量，我自己的名字
	public void sayHello( String name ){
		System.out.println(name+",Hi.I'm" + this.name + ".");
		//上面这两个 name 不是同一个 name		
		System.out.println(this);	//per的地址值		
	}	
}

this关键字的使用方法：

1、在本类的成员方法中，访问本类的成员变量； （重名变量时使用）
2、在本类的成员方法中，访问另一个成员方法；
3、在本类的构造方法中，访问本类的另一个构造方法。
（A、必须是那个方法中的第一条语句）
（B、super和this构造方法的调用，不能在同一个方法中）
4.表示当前对象的引用

1.调用当前对象的成员变量

Class Student
{
	private String name;
	private int age;
	private String sex;
	
	public void setName( String name )
	{
		this.name = name;
	}
}

2.this调用类中的方法

（1）this调用类当中的成员方法
public void test()
{
	
}
public void fun()
{
	test();
	//test是成员方法、必须通过对象调用
	//相当于this.test()
	//this代表引用当前对象
}

（2）this调用构造方法
若不同参数的构造方法之间出现了重复的调用，
可以使用 this(参数) 调用其他的 构造方法
this()代表调用无参构造
this(name)代表调用一个参数的有参构造

注意：
a.this调用其他构造方法，必须放在当前构造方法的首行
b.this调用构造方法，不能成 “ 环 ” 

class Person
{
	private String name;
	private int age;
	private String sex;
	
	public Person ()
	{
		System.out.println("Person的无参构造方法");
	}
	

	public Person ( String n )
	{
		this();
		name = n;
		System.out.println("Person的一个参数的有参构造");
	}
	public Person ( String n, int a )
	{
		this( n );
		age = a;
		System.out.println("Person的两个参数的有参构造");
	}

}

3.this表示当前对象的引用

了解即可，大家不需要掌握，认识一下
我当前是通过哪个对象调用的属性或者方法
this就代表谁：输出this等于那个对象的地址
地址一致，说明this就相当于那个对象

（3）构造方法进阶

进阶：

使用一个最常用的引用数据类型，一个普通的类，来看明白构造方法
在这里插入图片描述调试到第一个大括号：
在这里插入图片描述开始赋值：
在这里插入图片描述大括号结束：
在这里插入图片描述执行完毕：
在这里插入图片描述

赋值阶段，相当于：
在这里插入图片描述

（4）匿名对象

创建对象的标准格式：
类名称 对象名 = new 类名称() ;

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
注意事项：匿名对象只能使用一次，下次必须创建新的。

例： new Person(); new Person().name = "李"; 这是两个不同的匿名对象

Dog类

package pack03;

public class Dog
{
	String name;
	public void show(String name)
	{
		this.name = name;
		System.out.println("你们好，我叫：" + name );
	}
}

应用类

package pack03;

public class DemoDog
{
	public static void main(String[] args)
	{
		//左边的 one 就是对象的名字
		Dog one = new Dog();
		one.show();		
		//匿名对象
		new Dog().name = "joe";
		new Dog().show("marry");
		System.out.println("这是两个不同的匿名对象");		
	}	
}

结果 ：
在这里插入图片描述

（5）Object类

【1】Object类是所有Java类的根父类；
【2】如果在类的声明中未使用extends关键字指明，默认是Object类；
【3】多层继承中，Object一定是最高等级的类；
【4】Object类可以适用于所有的类的类型，与所有的类都是继承关系；
【5】子类可以执行父类的方法。

评论 39
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_小树

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值