喵星之旅-成长的雏鹰-java面向对象-3-封装与继承

成长的雏鹰java面向对象

封装

概念

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

实现

属性设为private，防止错误的修改
getter、seter用于属性的读写
对属性值的合法性进行判断

作用

便于使用者正确使用系统，防止错误修改属性
有助于系统之间的松耦合，提高系统独立性
提高软件的可重用性
降低了构建大型系统的风险

包组织类

概念

Windows树形文件系统
1、文档分门别类，易于查找和管理
2、使用目录解决文件同名冲突问题

如何存放两个同名的类而不冲突

包对应Java源文件的目录结构

实现

作为Java源代码第一条语句
用package声明包，以分号结尾

有开发工具的前提下，只需要选择对应的文件夹（包）创建类，自动配置好。

包命名规范

包名由小写字母组成，不能以圆点开头或结尾

包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名(例如：club.kittybunny)

包名后续部分依不同机构内部的规范不同而不同

作用

允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
有助于实施访问权限控制
防止命名冲突、区分名字相同的类

访问修饰符

类成员的访问修饰

Alt text

static

static可以用来修饰
成员变量
静态变量，可以直接通过类名访问

成员方法
静态方法，可以直接通过类名访问

代码块
静态代码块，当Java虚拟机加载类时，就会执行该代码块

类的成员变量包括:
1、类变量（静态变量）
被static修饰的变量
在内存中只有一个拷贝
类内部，可在任何方法内直接访问静态变量
其他类中，可以直接通过类名访问

2、实例变量
没有被static修饰的变量
每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

静态方法：可直接通过类名访问
静态方法中不能使用this和super
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法
实例方法：通过实例访问
可直接访问所属类的静态变量、静态方法、实例变量和实例方法
静态方法必须被实现

继承

概念

继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类。

实现

编写父类

1
2
3
4
[访问修饰符] class Pet { 
    //公共的属性和方法
}

编写子类，继承父类

1
2
3
4
[访问修饰符] class Dog extends Pet { 
    //子类特有的属性和方法
}

super

super只能出现在子类的方法和构造方法中
super调用构造方法时，只能是第一句
super不能访问父类的private成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
/**
 * 宠物类，狗狗和企鹅的父类
 */
public class Pet {
	private String name = "无名氏";// 昵称
	private int health = 100;// 健康值
	private int love = 20;// 亲密度
	
	/**
	 * 无参构造方法
	 */
	public Pet() {
		System.out.println("父类无参构造方法");
	}
	/**
	 * 有参构造方法
	 * @param name  昵称
	 */
	public Pet(String name) {
		System.out.println("父类带参构造方法");
		this.name = name;
	}
	
	public String getName() {
		return name;
	}



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



	public int getHealth() {
		return health;
	}



	public void setHealth(int health) {
		if(health<0||health>100){
			System.out.println("健康值应该在0至100之间，默认值为60。");
			this.health=60;
			return;
		}
		this.health = health;
	}



	public int getLove() {
		return love;
	}



	public void setLove(int love) {
		if(love<0||love>100){
			System.out.println("亲密度应该在0至100之间，默认值为10。");
			this.love=10;
			return;
		}
		this.love = love;
	}

	/**
	 * 输出宠物信息
	 */
	public void print() {
		System.out.println("宠物的自白：\n我的名字叫" + 
				this.name + "，我的健康值是" + this.health 
				+ "，我和主人的亲密程度是" + this.love + "。");
	}
}



/**
 * 狗狗类，宠物的子类
 */
public class Dog extends Pet {
	private String strain="牧羊犬";// 品种

	//无参构造方法
	public Dog() {
		System.out.println("子类无参构造方法");
	}
	
	public Dog(String name,String strain){
		super(name);
		this.strain=strain;
		System.out.println("子类带参构造方法");
	}
	
	public String getStrain() {
		return strain;
	}

	public void setStrain(String strain) {
		this.strain = strain;
	}
	
}



 
/**
 * 企鹅类，宠物的子类
 */
public class Penguin extends Pet {
	private String sex="Q仔";// 性别

	//无参构造方法
	public Penguin() {
		System.out.println("子类无参构造方法");
	}
	
	public Penguin(String name,String sex){
		super(name);
		this.sex=sex;
		System.out.println("子类带参构造方法");
	}
	
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}	
}


 
//测试类
public class Test {
	public static void main(String[] args) {
		// 1、创建宠物对象pet并输出信息
		Pet pet = new Pet("贝贝");
		pet.print();
		/*// 2、创建狗狗对象dog并输出信息
		Dog dog = new Dog();
		dog.setName("多多");
		dog.setHealth(90);
		dog.setLove(80);
		dog.setStrain("吉娃娃");
		dog.print();
		// 3、创建企鹅对象pgn并输出信息
		Penguin pgn = new Penguin();
		pgn.setName("大黑");
		pgn.setHealth(98);
		pgn.setLove(99);
		pgn.setSex("Q妹");
		pgn.print();*/
		
		Dog dog=new Dog("多多","吉娃娃");
		dog.print();
		Penguin pgn = new Penguin("大黑","Q妹");
		dog.print();
	}
}


1
2
3
4
5
6
7
继承条件下构造方法的调用规则
子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法
    系统默认调用父类的无参构造方法
子类构造方法通过super显式调用父类的有参构造方法
    执行父类相应构造方法，而不执行父类无参构造方法
子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

子类继承父类的什么？
继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里
继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里

文章目录
  1. 封装
    1. 概念
    2. 实现
    3. 作用
  2. 包组织类
    1. 概念
    2. 实现
      1. 包命名规范
    3. 作用
  3. 访问修饰符
    1. 类成员的访问修饰
    2. static
  4. 继承
    1. 概念
    2. 实现
    3. super
|