Java面向对象--------09_public string getpassword() { return password; } p-CSDN博客

本文链接：https://blog.csdn.net/qq_54287371/article/details/124457829

一、构造方法

1.1含义

与类名相同且没有返回项的方法，叫做构造方法

1.2注意

1.没有参数的构造方法简称无参构造
2.该类中没有有参构造的情况下，无参构造会被系统默认实现（经验：写了有参构造，就把无参构造给手动写上）

1.3作用

1.和new关键字在一起是创建对象的含义（会在堆内存中开辟空间）
2.初始化数据

package com.qf.test01;

public class Test01 {

	public static void main(String[] args) {
		
		Person p = new Person();
		
		p.name = "张三";
		p.sex = '男';
		p.age = 18;
		
		System.out.println(p.name);
		System.out.println(p.sex);
		System.out.println(p.age);
	
		p.eat();
	}
}

package com.qf.test01;

public class Person {

	String name;
	char sex;
	int age;
	
	public Person(){
	}
	
	public Person(String name, char sex, int age){
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	
	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}

1.31有参数构造方法

package com.qf.test01;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 		3.构造方法可以重载
		 * 
		 * 作用：
		 * 		1.和new关键字在一起是创建对象的含义（会在堆内存中开辟空间）
		 * 		2.初始化数据
		 */
		
		Person p = new Person("罗菌鱼", '男', 18);
		
		System.out.println(p.name);
		System.out.println(p.sex);
		System.out.println(p.age);
	
		p.eat();
	}
}

1.4private关键字

package com.qf.test02;

public class A {

	private String str = "A类的成员变量";
	
	private void method01(){
		System.out.println("A类的成员方法 - method01");
	}
	
	public void method02(){
		System.out.println(this.str);
		this.method01();
	}
}

package com.qf.test02;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：private
		 * 含义：私有化的
		 * 作用：
		 * 		1.修饰属性：该属性不能被外界使用
		 * 		2.修饰方法：该方法不能被外界使用
		 */
		
		A a = new A();
		
		a.method02();
	}
}

1.5方法版五子棋

package com.qf.test01;

//五子棋类
public class GoBang {

	//棋盘长度
	int len = 20;
	//棋盘容器
	String[][] goBang = new String[len][len];
	//棋盘符号
	String add = "╋";
	String[] nums = {"⒈","⒉","⒊","⒋","⒌","⒍","⒎","⒏","⒐","⒑","⒒","⒓","⒔","⒕","⒖","⒗","⒘","⒙","⒚","⒛"};
	String black = "■";
	String white = "○";

	//在构造方法中初始化棋盘数据和打印棋盘
	public GoBang() {
		//初始化数据
		init();

		//打印棋盘
		print();
	}

	//初始化棋盘数据
	private void init(){
		for (int i = 0; i < goBang.length; i++) {
			for (int j = 0; j < goBang[i].length; j++) {
				if(j == len-1){//每行的最后一列
					goBang[i][j] = nums[i];
				}else if(i == len-1){//最后一行
					goBang[i][j] = nums[j];
				}else{
					goBang[i][j] = add;
				}
			}
		}
	}

	//打印棋盘
	public void print(){
		for (String[] ss : goBang) {
			for (String str : ss) {
				System.out.print(str);
			}
			System.out.println();
		}
	}

	//判断坐标是否在棋盘范围内
	private boolean isIndexOutOfGoBang(int x, int y){
		if(x < 0 || x > len-2 || y < 0 || y > len-2){
			return false;
		}
		return true;
	}

	//判断坐标上是否有棋子
	private boolean isGoBang(int x, int y){
		if(!goBang[x][y].equals(add)){
			return false;
		}
		return true;
	}

	/**
	 * 落子
	 * @param x
	 * @param y
	 * @param bool true-黑子 false-白子
	 * @return 返回状态码
	 * 			-1 表示 落子失败 - 坐标在棋盘范围外
	 * 			-2 表示 落子失败 - 坐标上有棋子
	 * 			 1 表示 落子成功
	 */
	public int play(int x, int y,boolean bool){

		//判断坐标是否在棋盘范围内
		if(!isIndexOutOfGoBang(x, y)){
			return -1;
		}

		//判断坐标上是否有棋子
		if(!isGoBang(x, y)){
			return -2;
		}

		//落子
		goBang[x][y] = (bool)?black:white;
		return 1;
	}
}

package com.qf.test01;

import java.util.Scanner;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：面向对象版五子棋
		 */
		
		GoBang gb = new GoBang();

		Scanner scan = new Scanner(System.in);

		boolean bool = true;//true-黑子 false-白子

		while(true){

			//输入坐标
			System.out.println("请" + ((bool)?"黑":"白") + "子输入坐标：");
			int x = scan.nextInt()-1;
			int y = scan.nextInt()-1;

			//落子
			int play = gb.play(x, y, bool);
			
			if(play == -1){
				System.out.println("落子失败 - 坐标在棋盘范围外，请重新输入...");
				continue;
			}else if(play == -2){
				System.out.println("落子失败 - 坐标上有棋子，请重新输入...");
				continue;
			}

			//置反
			bool = !bool;

			//打印棋盘
			gb.print();
		}

	}
}

1.6构造方法内存图

二、无返回项构造方法

2.1含义

与类名相同且没有返回项的方法，叫做构造方法

2.2注意

1.没有参数的构造方法简称无参构造
2.该类中没有有参构造的情况下，无参构造会被系统默认实现（经验：写了有参构造，就把无参构造给手动写上）

2.3作用

1.和new关键字在一起是创建对象的含义（会在堆内存中开辟空间）

2.初始化数据

package com.qf.test01;

public class Person {

	String name;
	char sex;
	int age;
	
	static String str = "aaa";
	
	
	public Person(){
	}
	
	public Person(String name, char sex, int age){
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	
	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}

package com.qf.test01;

public class Test01 {

	public static void main(String[] args) {
		
		Person p = new Person();
		
		p.name = "张三";
		p.sex = '男';
		p.age = 18;
		
		System.out.println(p.name);
		System.out.println(p.sex);
		System.out.println(p.age);
	
		p.eat();
	}
}

2.31有参构造

package com.qf.test01;

public class Test02 {

	public static void main(String[] args) {
		Person p = new Person("罗菌鱼", '男', 18);
		
		System.out.println(p.name);
		System.out.println(p.sex);
		System.out.println(p.age);
	
		p.eat();
	}
}

2.4private关键字

package com.qf.test02;

public class A {

	private String str = "A类的成员变量";
	
	private void method01(){
		System.out.println("A类的成员方法 - method01");
	}
	
	public void method02(){
		System.out.println(this.str);
		this.method01();
	}
}

package com.qf.test02;

public class A {

	private String str = "A类的成员变量";
	
	private void method01(){
		System.out.println("A类的成员方法 - method01");
	}
	
	public void method02(){
		System.out.println(this.str);
		this.method01();
	}
}

三、封装

3.1含义

对成员变量的一种保护措施

3.2步骤

1.私有化属性（目的：让外界不能调用）
2.添加set(设置-传参)/get(获取-返回属性)方法

3.3好处

外界不能随便调用成员变量，必须通过get/set方法，我们可以在set/get方法中去编写额外的功能
总结：所有的属性都要封装

3.4需求

需求：模拟银行用户的操作金额的过程

分析：
银行有个用户类 -- User
实际操作的是User类的对象

package com.qf.test03;

import java.time.LocalDateTime;

//用户类
public class User {

	private String username;
	private String password;
	private double money;
	
	public User() {
	}

	public User(String username, String password, double money) {
		this.username = username;
		this.password = password;
		this.money = money;
	}
	
	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public void setMoney(double money){
		this.money = money;
		
		//LocalDateTime.now() -- 获取当前系统的时间
		System.out.println(this.username + " -- " + LocalDateTime.now() + "设置了money属性：" + this.money);
	}
	
	public double getMoney(){
		
		//LocalDateTime.now() -- 获取当前系统的时间
		System.out.println(this.username + " -- " + LocalDateTime.now() + "查看了money属性：" + this.money);
		
		return money;
	}
	
	
}

package com.qf.test03;

public class Test01 {

	public static void main(String[] args) {

		User user = new User("1445584980", "123123", 10000);
		
		//1.获取user对象中money属性->1000
		//2.10000减1800->8200
		//3.将8200设置给user对象中的money属性
		//user.money = user.money-1800;
		//获取user对象的money属性
		//System.out.println(user.money);//8200
		
		//1.获取user对象中money属性->1000
		//2.10000减1800->8200
		//3.将8200设置给user对象中的money属性
		user.setMoney(user.getMoney()-1800);
		
		//获取user对象的money属性
		System.out.println(user.getMoney());//8200
	}
}

四、this关键字

4.1含义

方法中的this表示调用该方法的对象

4.2作用

1.this.属性：调用本对象的成员变量
2.this.方法：调用本对象的成员方法
3.this()：调用本对象的构造方法（在一个构造方法的第一句调用另外一个构造方法）

package com.qf.test04;

public class Person {
	
	private String name;
	private char sex;
	private int age;
	
	public Person() {
		//调用有参构造
		this("亚当", '男', 0);
	}

	public Person(String name, char sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
	
	public void writeCode(){
		System.out.println(this.name + "写代码");
	}

	//休息的方法
	public void rest(){
		//利用this调用成员方法
		this.eat();
		this.writeCode();
		this.sleep();
	}
}

package com.qf.test04;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：this
		 * 含义：方法中的this表示调用该方法的对象
		 * 作用：
		 * 	1.this.属性：调用本对象的成员变量
		 * 	2.this.方法：调用本对象的成员方法
		 * 	3.this()：调用本对象的构造方法（在一个构造方法的第一句调用另外一个构造方法）
		 */
		
		Person p = new Person();
		
		p.rest();
	}
}

五、static修饰属性

5.1属于类的变量

类加载到方法区时，JVM会扫描该类的所有属性
并把静态属性加载到静态区中，静态属性属于类属性，
该类所有的对象都共享该属性
静态属性直到项目结束时才会被回收
应用场景：该类所有的对象都共享的变量，就把该变量设置为静态变量

5.2应用场景

该类所有的对象都共享的变量，就把该变量设置为静态变量

package com.qf.test05;

public class A {
	
	//成员变量
	String str1;

	//静态变量
	static String str2;
}

package com.qf.test05;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：static修饰属性
		 * 含义：属于类的变量
		 * 
		 * 类加载到方法区时，JVM会扫描该类的所有属性
			并把静态属性加载到静态区中，静态属性属于类属性，
			该类所有的对象都共享该属性
			静态属性直到项目结束时才会被回收
		 * 
		 * 应用场景：该类所有的对象都共享的变量，就把该变量设置为静态变量
		 */
		
		A a1 = new A();
		A a2 = new A();
	
		a1.str1 = "aaa";
		a2.str1 = "bbb";
		System.out.println(a1.str1);//aaa
		System.out.println(a2.str1);//bbb
		
//		a1.str2 = "xxx";
//		a2.str2 = "yyy";
//		System.out.println(a1.str2);//yyy
//		System.out.println(a2.str2);//yyy
	
		A.str2 = "xxx";
		A.str2 = "yyy";
		System.out.println(A.str2);//yyy
		System.out.println(A.str2);//yyy
	}
}

5.3类加载面试题

5.31 面试题1

package com.qf.test06;

public class A {
	//准备阶段1：为静态变量开辟空间
	//A a;
	//int value1;
	//int value2;
	//准备阶段2：为静态变量赋系统默认值
	//A a = null;
	//int value1 = 0;
	//int value2 = 0;
	//初始化阶段
	//A a = new A();
	//int value1 = 0;
	//int value2 = 1;

	static A a = new A();
	static int value1 = 0;
	static int value2;
	
	public A() {
		value1++;
		value2++;
	}
}

package com.qf.test06;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：类加载机制面试题
		 */
		
		System.out.println(A.value1);//0
		System.out.println(A.value2);//1
	}
}

5.32面试题2

package com.qf.test07;

public class A {
	//准备阶段1：为静态变量开辟空间
	//int value1;
	//int value2;
	//A a;

	//准备阶段2：为静态变量赋系统默认值
	//int value1 = 0;
	//int value2 = 0;
	//A a = null;	

	//初始化阶段
	//int value1 = 1;
	//int value2 = 1;
	//A a = new A();

	static int value1 = 0;
	static int value2;
	static A a = new A();
	
	public A() {
		value1++;
		value2++;
	}
}

package com.qf.test07;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：类加载机制面试题
		 */
		
		System.out.println(A.value1);//1
		System.out.println(A.value2);//1
	}
}

六、总结

1.构造方法
   与类名相同且没有返回项的方法
   作用：
       1.和new一起，创建对象
       2.初始化数据

2.private
   修饰属性：私有化属性，不能让外界调用
   修饰方法：私有化方法，不能让外界调用

3.封装
   私有化属性
   添加get、set方法

4.this（方法中的this表示调用该方法的对象）
   this.属性：调用本对象的成员属性
   this.方法：调用本对象的成员方法
   this()：调用本对象的构造方法

5.分包（防止类的重名）

6.static修饰属性
   类加载到方法区时会在静态区加载静态属性
   项目结束时(main方法结束时)，静态属性才会被回收

7.扩展 - 类加载机制