9初始面向对象
初识面向对象
1. this关键字
this关键字：表示当前对象
适用场景：
1.可以访问属性2.可以访问方法3.可以访问构造方法，必须在构造方法的第一句
package com.qfedu.test1;
/**
* 名字
* 年龄
* 性别
*
* this关键字：表示当前对象
* 适用场景：
* 1.可以访问属性
* 2.可以访问方法
* 3.可以访问构造方法，必须在构造方法的第一句
*
* @author WHD
*
*/
public class Person {
String name;
int age;
String sex;
public void printName() {
System.out.println("我的名字是：" + name);
}
public void printAge() {
System.out.println("我的年龄是:" + age);
}
public void printInfo() {
this.printName();
this.printAge();
System.out.println("性别是:" + sex);
}
public Person(String name) {
this.name = name;
}
public Person(String name,int age) {
this(name);
this.age = age;
}
public Person(String name,int age,String sex) {
this(name,age); // 调用本类构造 必须在构造方法的第一句
this.sex = sex;
}
public Person(int a,String s,String n) {
sex = s;
age = a;
name = n;
}
public Person() {}
}
封装和继承
1. 封装
解决用户不合理的给属性赋值的情况，我们可以使用封装来实现
封装的步骤：
1.属性私有 属性使用private关键字修饰 表示此属性只能在本类中访问 其他任何类不能访问
2.方法公开 每一个属性编写一对方法 分别用于属性的赋值(set方法) 和 取值(get方法)
公开方法 有严格的命名规范要求
获取值的 必须为 getName() 不需要参数 但是需要返回值
设置值的 必须为 setName() 不需要返回值 但是需要参数
封装的优点：
便于使用者正确使用系统，防止错误修改属性
降低了构建大型系统的风险
提高程序的可重用性
降低程序之间的耦合度
package com.qfedu.test2;
/**
* 企鹅类
*
* 名字
* 健康值
* 爱心值
*
* 解决用户不合理的给属性赋值的情况，我们可以使用封装来实现
* 封装的步骤：
* 1.属性私有 属性使用private关键字修饰 表示此属性只能在本类中访问 其他任何类不能访问
* 2.方法公开 每一个属性编写一对方法 分别用于属性的赋值(set方法) 和 取值(get方法)
* 公开方法 有严格的命名规范要求
* 获取值的 必须为 getName() 不需要参数 但是需要返回值
* 设置值的 必须为 setName() 不需要返回值 但是需要参数
* @author WHD
*
*/
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("健康值赋值不合理，将使用默认值60");
this.health = 60;
}
}
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("爱心值赋值不合理，将使用默认值60");
this.love = 60;
}
}
public int getLove() {
return love;
}
}
package com.qfedu.test2;
public class TestPenguin {
public static void main(String[] args) {
Penguin p1 = new Penguin();
p1.setName("大白");
p1.setHealth(-2000);
p1.setLove(-2000);
System.out.println("名字是：" + p1.getName());
System.out.println("健康值是：" + p1.getHealth());
System.out.println("爱心值是：" + p1.getLove());
System.out.println("----------------------------");
Penguin p2 = new Penguin();
p2.setName("小黑");
p2.setLove(88);
p2.setHealth(95);
System.out.println("名字是：" + p2.getName());
System.out.println("健康值是：" + p2.getHealth());
System.out.println("爱心值是：" + p2.getLove());
// p1.name = "大白";
// p1.health = -200;
// p1.love = -300;
//
// System.out.println("名字是：" + p1.name);
// System.out.println("健康值是：" + p1.health);
// System.out.println("爱心值是：" + p1.love);
}
}
2. 访问权限修饰符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U9weMgMb-1665050011193)(.\img\访问修饰符.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cWkaVLEU-1665050011194)(.\img\访问修饰符2.png)]
2.1 类的访问修饰符
类的访问修饰符
public:公开的访问权限 本项目任何位置 都可以访问此类
默认不写：表示只能在同一个包中访问此类
package com.qfedu.test3;
/**
* 类的访问修饰符
* public:公开的访问权限 本项目任何位置 都可以访问此类
* 默认不写：表示只能在同一个包中访问此类
* @author WHD
*
*/
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) {
B b = new B();
}
}
package com.qfedu.test3;
public class TestA {
public static void main(String[] args) {
A a = new A();
B b = new B();
}
}
package com.qfedu.test4;
import com.qfedu.test3.A;
//import com.qfedu.test3.B;
public class TestA {
public static void main(String[] args) {
A a = new A();
// B b = new B();
}
}
2.2 类成员的访问修饰符
类成员(属性和方法)的访问修饰符
- private 本类中
- 默认不写 本包中
- protected 本类 本包 子类
- public 任何位置
package com.qfedu.test5;
/**
* 类成员(属性和方法)的访问修饰符
* private 本类中
* 默认不写 本包中
* protected 本类 本包 子类
* public 任何位置
*
* @author WHD
*
*/
public class A {
private String field1; // 字段 属性 一个意思
String field2;
protected String field3;
public String field4;
private void m1() {
System.out.println("private修饰的m1方法");
}
void m2() {
System.out.println("默认修饰符修饰的m2方法");
}
protected void m3() {
System.out.println("protected修饰的m3方法");
}
public void m4() {
System.out.println("public修饰的m4方法");
}
public static void main(String[] args) {
A a = new A();
System.out.println(a.field1);
System.out.println(a.field2);
System.out.println(a.field3);
System.out.println(a.field4);
a.m1();
a.m2();
a.m3();
a.m4();
}
}
package com.qfedu.test5;
public class TestA {
public static void main(String[] args) {
A a = new A();
System.out.println(a.field2);
System.out.println(a.field3);
System.out.println(a.field4);
a.m2();
a.m3();
a.m4();
}
}
package com.qfedu.test6;
import com.qfedu.test5.A;
public class TestA {
public static void main(String[] args) {
A a = new A();
System.out.println(a.field4);
a.m4();
}
}
3. static关键字
3.1 修饰属性
static可以用来修饰
成员变量
静态变量，可以直接通过类名访问
static关键字修饰的属性，在内存中只有一份，可以用于数据的共享，节省内存空间，
static修饰的变量/属性，推荐使用类名.属性名访问 因为静态变量属于整个类 不属于任何对象
是被所有当前类对象共享的数据
package com.qfedu.test7;
/**
* static可以用来修饰
* 成员变量
* 静态变量，可以直接通过类名访问
*
* static关键字修饰的属性，在内存中只有一份，可以用于数据的共享，节省内存空间，
* static修饰的变量/属性，推荐使用类名.属性名访问 因为静态变量属于整个类 不属于任何对象
* 是被所有当前类对象共享的数据
*
* 名字
* 年龄
* 班级
* @author WHD
*
*/
public class Student {
String name;
int age;
static String gradeName = "三年二班";
public static void main(String[] args) {
Student stu1 = new Student();
stu1.name = "赵四";
stu1.age = 20;
stu1.gradeName = "三年三班";
Student stu2 = new Student();
stu2.name = "广坤";
stu2.age = 21;
Student stu3 = new Student();
stu3.name = "大拿";
stu3.age = 22;
Student stu4 = new Student();
stu4.name = "刘能";
stu4.age = 19;
System.out.println(stu1.gradeName);
System.out.println(stu2.gradeName);
System.out.println(stu3.gradeName);
System.out.println(stu4.gradeName);
// 问题 目前我们创建了四个对象 这四个对象有一个共同的信息 "三年二班" 这个信息在内存中存在多次
// 造成内存浪费 不太合理
}
}
package com.qfedu.test7;
/**
* 模拟饮水机 接水
* @author WHD
*
*/
public class DrinkWater {
static int capacity = 1000;
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) {
DrinkWater zhaosi = new DrinkWater();
zhaosi.name = "赵四";
zhaosi.getWater();
DrinkWater dana = new DrinkWater();
dana.name = "大拿";
dana.getWater();
DrinkWater liuneng = new DrinkWater();
liuneng.name = "刘能";
liuneng.getWater();
}
}
3.2 修饰方法
静态方法，可以直接通过类名访问
package com.qfedu.test8;
public class Test1 {
public static void m1() {
System.out.println("静态方法m1");
}
public static void main(String[] args) {
Test1 test1 = new Test1();
m1();
}
}
package com.qfedu.test8;
public class Test2 {
public static void main(String[] args) {
Test1.m1();
}
}
3.3 修饰代码块
静态代码块，当Java虚拟机加载类时(类只加载一次)，就会执行该代码块
类加载的时机：
1.new对象会加载类
2.访问类中的信息 会加载类 比如访问静态变量
static代码块应用场景：用于实现一些前置的，必要的操作，并且只需要执行一次。比如数据初始化
package com.qfedu.test8;
/**
* 静态代码块，当Java虚拟机加载类时(类只加载一次)，就会执行该代码块
*
* 类加载的时机：
* 1.new对象会加载类
* 2.访问类中的信息 会加载类 比如访问静态变量
*
* static代码块应用场景：用于实现一些前置的，必要的操作，并且只需要执行一次。比如数据初始化
* @author WHD
*
*/
public class Test3 {
static int numa = 100;
static {
System.out.println("静态代码块1");
}
static {
System.out.println("静态代码块2");
}
public static void main(String[] args) {
// System.out.println(numa);
Test3 t1 = new Test3();
Test3 t2 = new Test3();
Test3 t3 = new Test3();
}
}
。比如数据初始化
package com.qfedu.test8;
/**
* 静态代码块，当Java虚拟机加载类时(类只加载一次)，就会执行该代码块
*
* 类加载的时机：
* 1.new对象会加载类
* 2.访问类中的信息 会加载类 比如访问静态变量
*
* static代码块应用场景：用于实现一些前置的，必要的操作，并且只需要执行一次。比如数据初始化
* @author WHD
*
*/
public class Test3 {
static int numa = 100;
static {
System.out.println("静态代码块1");
}
static {
System.out.println("静态代码块2");
}
public static void main(String[] args) {
// System.out.println(numa);
Test3 t1 = new Test3();
Test3 t2 = new Test3();
Test3 t3 = new Test3();
}
}