面向对象-封装

初识面向对象 1. 万物皆对象

是指自然界中的任何事物都可以理解为一个对象，通过分析其特征和行为，将当前事务具体化为一个对象。

2.类和对象的关系

类是对象的抽象，对象是类的具体。

类是抽象的概念，比如电脑类，人类，动物类…… 是指某一大类，不能明确指定某个真实存在的个体

对象是真真实实存在的个例，比如赵四，广坤，联想拯救者9代i7

3.属性和方法

一些事物共有的特征，称之为属性

一些事物共有的行为，称之为方法

类是有属性和方法组成的

4. 创建类和对象

1.通过new关键字来创建对象类名对象名 = new 类名();

2.通过对象名.属性名给属性赋值是对象更加具体

3.通过对象名.方法名执行对象的行为 (动作，功能)

package com.qfedu.test1;

public class Student {
	String name;
	int age;
	double height;
	String sex;
	double weight;
	String studentNo;
	String gradeName;
	String address;
	
	public void study() {
		System.out.println("好好学习");
	}
	
	public void sport() {
		System.out.println("做运动");
	}
	
	public void eat() {
		System.out.println("好好吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
	
	public void love() {
		System.out.println("谈恋爱");
	}
	
	public void playGame() {
		System.out.println("打游戏");
	}
	
	
	
	public static void main(String[] args) {
		// 1.通过new关键字来创建对象  类名 对象名 = new 类名();
		Student zhaosi = new Student(); 
		
		// 2.通过对象名.属性名 给属性赋值 是对象更加具体
		zhaosi.name = "赵四";
		zhaosi.age = 17;
		zhaosi.address = "象牙山";
		zhaosi.gradeName = "三年二班";
		zhaosi.height = 175.5;
		zhaosi.weight = 70;
		zhaosi.sex = "男";
		zhaosi.studentNo = "zz666";
		
		// 3.通过对象名.方法名 执行对象的行为 (动作，功能)
		zhaosi.study();
		zhaosi.eat();
		zhaosi.sleep();
		zhaosi.love();
		zhaosi.playGame();
		zhaosi.sport();
		
		System.out.println("---------------------------------------");
		Student guangkun = new Student();
		
		guangkun.name = "广坤";
		guangkun.gradeName = "三年二班";
		guangkun.age = 20;
		guangkun.address = "象牙山";
		guangkun.height = 180;
		guangkun.weight = 85;
		guangkun.sex = "男";
		guangkun.studentNo = "zz888";
		
		guangkun.study();
		guangkun.eat();
		guangkun.sleep();
		guangkun.playGame();
		guangkun.love();
		guangkun.sport();
		
	}	
}

5. 实例变量和局部变量

描述	局部变量	实例变量
定义位置	定义在方法中	定义在类中
作用范围	离当前变量最近的大括号以内	整个类中
默认值	没有默认值，必须先赋值才能使用	有默认值与数组相同
重名	重合的作用范围不能重名	可以与局部变量重名，局部变量优先使用
存储位置	基本数据类型存在栈中；引用数据类型名字在栈，值在堆	实例变量全部存在堆中，与数组是同一个性质的
生命周期	随着方法的入栈而生效，随着方法的出栈而死亡	随着对象的创建而生效，随着对象被垃圾回收而死亡

6. 构造方法

构造方法：创建对象的特殊方法，JVM默认提供无参构造方法，创建对象的时候自动调用

书写格式：访问修饰符 + 类名(形参列表){}

注意:无参构造方法默认存在，如果书写了有参构造方法，无参构造将会被覆盖，如需使用，必须显式书写

package com.qfedu.test3;

public class Teacher {
	String name;
	String profession;
	String course;
	int teachYear;
	
	public Teacher() {
		System.out.println("Teacher类无参构造方法执行了");
	}
	
	public Teacher(String n,String p,String c,int t) {
		name = n;
		profession = p;
		course = c;
		teachYear = t;
	}
	
	
	public static void main(String[] args) {
		Teacher zhaosi = new Teacher();
		zhaosi.name = "赵四";
		zhaosi.profession = "形体专业";
		zhaosi.course = "民族艺术与街头艺术的摩擦";
		zhaosi.teachYear = 10;
		
		Teacher guangkun = new Teacher("广坤", "口技", "语言艺术", 15);
		
		System.out.println(guangkun.name);
		System.out.println(guangkun.profession);
		System.out.println(guangkun.course);
		System.out.println(guangkun.teachYear);
		
		
	}
	
	
	
}

7. 构造方法重载

构造方法重载：同一个类中的构造方法，参数列表不同(个数、类型、顺序)

package com.qfedu.test4;

public class Teacher {
	String name;
	String profession;
	String course;
	int teachYear;
	
	public Teacher() {
		System.out.println("Teacher类无参构造方法执行了");
	}
	
	public Teacher(String n,String p,String c,int t) {
		name = n;
		profession = p;
		course = c;
		teachYear = t;
	}
	
	public Teacher(String n) {
		name = n;
	}
	
	public Teacher(String n,int t) {
		name = n;
		teachYear = t;
	}
	
	
	
	public void printTeacher() {
		System.out.println("老师的名字是：" + name + "专业是：" + profession + "课程：" + course + "教龄" + teachYear);
	}
	
	
	public static void main(String[] args) {
		Teacher zhaosi = new Teacher();
		zhaosi.name = "赵四";
		zhaosi.profession = "形体专业";
		zhaosi.course = "民族艺术与街头艺术的摩擦";
		zhaosi.teachYear = 10;
		
		Teacher guangkun = new Teacher("广坤", "口技", "语言艺术", 15);
		
		System.out.println(guangkun.name);
		System.out.println(guangkun.profession);
		System.out.println(guangkun.course);
		System.out.println(guangkun.teachYear);
		
		Teacher dana = new Teacher("大拿");
		dana.profession = "人才管理";
		dana.course = "小康致富之路";
		dana.teachYear = 20;
		dana.printTeacher();
		
		
	}

}

8. this关键字

this关键字：表示当前对象

this关键可以访问：

1.属性
2.方法
3.构造方法，必须在本类构造的第一句

package com.qfedu.test5;

public class Teacher {
	String name;
	String profession;
	String course;
	int teachYear;
	
	public Teacher() {
	}
	public Teacher(String name) {
		this.name = name;
	}
	
	public Teacher(String name,int teachYear) {
		this(name);
		this.teachYear = teachYear;
	}
	public Teacher(String name,String profession,String course,int teachYear) {
		this(name, teachYear);
		this.profession = profession;
		this.course = course;
	}
	
	
	
	public void printName() {
		System.out.println("老师的名字是：" + name);
	}
	
	public void printTeacher() {
		this.printName();
		System.out.println("专业是：" + profession + "课程：" + course + "教龄" + teachYear);
	}
	
	
	public static void main(String[] args) {
		Teacher t1 = new Teacher("赵四", "形体艺术", "街头舞蹈", 10);
	}
	
	
	
}

封装 1. 概念

封装：将类的信息隐藏在类的内部，不让外部直接访问，而是提供公开的方法来实现对信息的访问

封装的步骤：

1.属性私有:将属性使用private修饰，表示此属性只能在本类中可以访问

2.方法公开：每个属性书写两个方法

getter方法用于获取属性值

setter方法用于设置属性值

注意：方法名格式：set+ 属性名首字母大写 get + 属性名首字母大写

2. 封装的优点

便于使用者正确使用系统，防止错误修改属性

降低了构建大型系统的风险

提高程序的可重用性

降低程序之间的耦合度

package com.qfedu.test1;

public class Penguin {
	private String name;
	public void setName(String name){
		this.name = name;
	}
	public String getName() {
		return name;
	}
	private int health;
	public void setHealth(int health) {
		if(health >= 0 && health <= 100) {
			this.health = health;
		}else {
			System.out.println("健康值赋值不合理，将使用默认值80");
			this.health = 80;
		}
	}
	public int getHealth() {
		return health;
	}
	private int love;
	public void setLove(int love) {
		if(love >= 0 && love <= 100) {
			this.love = love;
		}else {
			System.out.println("爱心值赋值不合理，使用默认值80");
			this.love = 80;
		}
	}
	public int getLove() {
		return love;
	}
	
	
	public static void main(String[] args) {
		Penguin p = new  Penguin();
		p.name = "大白";
		p.health = -2000;
		p.love = -3333;
		
		System.out.println(p.name);
		System.out.println(p.health);
		System.out.println(p.love);
		
	}
}

package com.qfedu.test1;

public class TestPenguin {
	public static void main(String[] args) {
		Penguin p = new Penguin();
		
//		p.name = "小白";
//		p.health = -666;
//		p.love = -888;
//		
//		System.out.println(p.name);
//		System.out.println(p.health);
//		System.out.println(p.love);				
		
		p.setName("大白");
		p.setHealth(-360);
		p.setLove(-888);
		
		System.out.println("--------------------------------------");
		
		System.out.println(p.getName());
		System.out.println(p.getLove());
		System.out.println(p.getHealth());		
	}
}

3.访问权限修饰符 3.1 类的访问权限修饰符

类的访问权限修饰符：

public :表示在本项目中都可以访问此类

默认不写：包级别的，表示只能在同包中访问

package com.qfedu.test2;

public class A {
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
	}
}


      class B{
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
	}
}

package com.qfedu.test3;

import com.qfedu.test2.A;
//import com.qfedu.test2.B;

public class TestAB {
	public static void main(String[] args) {
		A a = new A();
		
//		B b = new B();
	}
}

3.2 类成员的访问权限修饰符

package com.qfedu.test4;

public class C {
	private 	String field1;
				String field2;
	protected 	String field3;
	public  	String field4;
	
	private 	void m1() {}
	
				void m2() {}
	
	protected 	void m3() {}
	
	public 		void m4() {}
	
	
	public static void main(String[] args) {
		C c = new C();
		System.out.println(c.field1);
		System.out.println(c.field2);
		System.out.println(c.field3);
		System.out.println(c.field4);
		
		
		c.m1();
		c.m2();
		c.m3();
		c.m4();
		
		
	}
	
	
}

package com.qfedu.test4;

public class TestC {
	public static void main(String[] args) {
		C c = new C();
		System.out.println(c.field2);
		System.out.println(c.field3);
		System.out.println(c.field4);
		
		c.m2();
		c.m3();
		c.m4();
	}
}

package com.qfedu.test5;

import com.qfedu.test4.C;

public class TestC {
	public static void main(String[] args) {
		C c = new C();
		System.out.println(c.field4);
		
		c.m4();
	}
}

4. static关键字

方法区：是SUN公司制定的一个规范，具体的名称为永久代/元数据

元数据/永久代：负责加载class文件(加载类)，存放静态相关的信息 static修饰的数据

类加载的过程：当我们new一个对象

1.JVM先在方法区中查看当前对象所属类是否已经被加载

如果没有被加载，先加载当前类信息文件(class文件)

如果已经加载过了，直接执行第二步

2.在堆中开辟空间，此时实例属性都将拥有默认值

3.将栈中引用指向堆中的空间

4.1 修饰属性

static修饰属性：表示此属性属于整个类，不属于任何对象，在内存中只存在一份，用于实现数据的共享

类内部，可在任何方法内直接访问静态变量

其他类中，可以直接通过类名访问

package com.qfedu.test6;

public class Water {
	static int capacity = 1000; // 水总容量 1000ml
	String name;
	
	
	public void getWater() {
		if(capacity > 0) {
			capacity -= 200;
			System.out.println(name + "接水200ml，还剩余" + capacity + "ml");
		}else {
			System.out.println("没水了");
		}
	}
	
	public static void main(String[] args) {
		Water zhaosi = new Water();
		zhaosi.name = "赵四";
		zhaosi.getWater();
		// 这一行代码有两层含义 1.zhaosi这个引用不再指向原来的对象空间 2.原来的对象空间没有任何引用指向它
		// 接下来zhaosi指向的对象空间将会被垃圾回收  GC  Garbage Collection
		zhaosi = null; 
		
		
		
		Water guangkun = new Water();
		guangkun.name = "广坤";
		guangkun.getWater();
		
		Water dana = new Water();
		dana.name = "大拿";
		dana.getWater();
		
	}
}

4.2 修饰方法

静态方法

本类中直接访问，其他类通过类名访问，不需要new对象

package com.qfedu.test8;

public class TestStaticMethod {
	int num;
	static int numa;
	
	public static void m1() {
		TestStaticMethod tsm = new TestStaticMethod();
		System.out.println(tsm.num); // 先new对象才能访问 
//		this.num = 20;
		System.out.println("静态方法m1");
		System.out.println(numa);
	}
	
	public void m2() {
		this.num = 20;
		System.out.println(numa);
	}
	
	
	
	public static void main(String[] args) {
		TestStaticMethod tsm = new TestStaticMethod();
		System.out.println(tsm.num);
		m1();
	}
	
}


class B{
	public static void main(String[] args) {
		TestStaticMethod.m1();
	}
}

4.3 修饰代码块

静态代码块：随着JVM加载类就会执行，多个静态代码块按照书写顺序执行，每个只执行一次

什么情况下JVM会加载类：

1.new对象

2.访问类的信息

应用场景：用于数据初始化，连接数据库等前置操作

package com.qfedu.test8;

public class TestStaticCode {
	static int num;
	
	static {
		System.out.println("静态代码块1");
	}
	
	static {
		System.out.println("静态代码块2");
	}
	
	static {
		System.out.println("静态代码块3");
	}
	
	{
		System.out.println("普通代码块1");
	}
	
	{
		System.out.println("普通代码块2");
	}
	
	
	
	
	public static void main(String[] args) {
		System.out.println(num);
		
		TestStaticCode tsc1 = new TestStaticCode();
//		
		TestStaticCode tsc2 = new TestStaticCode();
//		
//		TestStaticCode tsc3 = new TestStaticCode();
//		
//		TestStaticCode tsc4 = new TestStaticCode();
	}
}

4.4 访问规则

1.同级别互相直接访问

2.实例访问静态直接访问

3.静态访问实例先new对象

面向对象-封装

Java相关栏目本月热门文章