第六章 封装和继承 ① 笔记

内容回顾

 数组的定义和使用
 常见算法

本章内容

 封装
 继承
 super关键字
 方法重写
 final关键字在继承中的使用

第一节 封装

生活中的封装: 电视机，空调，ATM机

1.1 什么是封装

封装，即隐藏对象的属性和实现细节，仅对外公开接口（方法/函数），控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中属性数据和函数都是类的成员。
封装的目的：是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。

1.2 java中的封装

广义来说：一切公共代码的抽取都可以叫封装。
一般体现在公共方法的封装。工具类。
狭义来说(属性封装)：隐藏对象的属性和实现细节。
1. 将属性私有化 ，使用private关键字修饰。
2. 为使用private关键字修饰的属性添加 getter和setter方法。通过get和set方法来操作属性。
3. 在setter方法中，添加数据的逻辑校验。

为什么要使用getter和setter（访问器和更改器）？

以上红色标红部分，也是对我疑问的回答！
想要了解更过关于getter和setter的用法，请参考：Java Getter和Setter

快捷键alt+insert

快速生成代码:构造方法，getter,setter,方法重写，toString

package com.test3;
public class Student {
	//属性封装:1.属性私有化 2.添加getter setter方法 3.在setter方法中进行数据校验
	//姓名
	private String name;
	//性别
	private String sex;
	//年龄
	private int age;
	public void show(){
		System.out.println(this.name+" "+this.sex+" "+this.age);
	}
	//生成getter setter
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		//在setter方法中对数据进行校验
		if(sex.equals("男")||sex.equals("女")){
			this.sex = sex;
		}else{
			System.out.println("性别无效");
		}
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>0 && age<120){
			this.age = age;
		}else{
			System.out.println("年龄超出范围");
			}
		}
	}
	
package com.test3;
public class Test {
	public static void main(String[] args) {
		Student s=new Student();
		// s.name="张三";
		// s.sex="石头";
		// s.age=-20;
		s.setName("张三");
		s.setSex("石头");
		s.setAge(-20);
		s.show();
	}
}

1.3 封装的作用

保护属性的有效性。

第二节 继承

2.1 什么是继承

继承是面向对象软件技术当中的一个概念，与多态、封装共称为面向对象的三个基本特征。继承可以使得子类具有父类的非私有属性和方法或者可以重新定义、追加属性和方法等。
继承（英语：inheritance）。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
如果某类B“继承”另某类A，就把这个B称为“A的子类或派生类（subclass）”，而把类A称为“B的父类”也可以称为“A是B的超类或基类（superclass）”。

2.2 为什么需要继承

提升代码的可重用性

 子类通过继承可以得到父类有的内容

能够扩展功能

 通过继承，子类可以扩展父类已有的功能

方便维护

 多个子类都继承了父类的某个功能，当功能需要修改时，只要修改父类的这个功能即可
使用面向对象思想编程的时候，需要考虑的两个方面：
1.功能实现了没有？
2.后期维护方便吗？

2.3 继承的语法格式

java语言是单继承的，java类只能由一个父类。

继承的语句格式：

[权限修饰符] class 子类名 extends 父类名{}
	// 定义父类
	public class Father {
		// 父亲有500w元
		int money = 5000000;
		public void liveHouse(){
			System.out.println("住80年代老房子");
		}
	}
	// 定义子类
	public class Son extends Father{
	}
	public class Test {
		public static void main(String[] args) {
		Son son = new Son();
		System.out.println("儿子有:"+son.money+"元");
		son.liveHouse();
	}
}

运行结果:

儿子有:5000000元
住80年代老房子

2.4 方法重写 @Override注解

快捷键alt+insert

然后再进行编辑重写即可！

什么是方法重写

在Java和其他一些高级面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

方法重写和方法重载的区别：

重载(overload)：发生在同一个类中 , 方法名相同，参数列表不同，不考虑返回值。
重写(overrides)：发生在父子类中，子类继承父类的方法，方法名相同，参数也相同，但是实现方法体不同。

 重写的注意事项

 必须保证父子类中重写的方法，方法名相同，参数列表相同。
 子类方法的返回值必须小于或等于父类方法的返回值范围。
 子类方法的权限必须要大于等于父类方法的权限（不包括 private）
 子类重写方法异常声明必须是父类的异常或子级异常
 私有的不能被继承

toString()方法

 任何类都是Object类的直接子类或者间接子类,在Object类中有一个toString()方法。当输出一个对象时，先调用当前类的toString()方法，如果当前类没有toString() ，就去找当前类的父类，看是否有toString()方法,如果过父类也没有，就去找Object类中的toString()方法并运行。

数据模型类

 以后写类都要有：成员属性私有化，成员方法，构造方法，get/set方法 ,toString()
继承实例

	// Father.java
	// 父亲类
	public class Father {
		// 父亲有500w元
		int money = 5000000;
		public void liveHouse(){
			System.out.println("住80年代老房子");
		}
	}
	// Son.java
	// 儿子类
	public class Son extends Father{
			// 重写父类方法
			@Override
			public void liveHouse() {
			System.out.println("住海景洋房");
		}
	}
	// Test.java
	// 测试类
	public class Test {
		public static void main(String[] args) {
			Son son = new Son();
			System.out.println("儿子有:"+son.money+"元");
			son.liveHouse();
		}
	}

运行结果：

儿子有:5000000元
住海景洋房

2.5 super关键字(父类对象)，this关键字(当前类对象)

作用：如果子类既想使用自己的方法，又想使用父类的成员变量和成员方法，需要通过super关键字。
super 关键字的用法：

1. 在子类的成员方法中访问父类的成员变量和成员方法。
2. 在子类的构造方法中访问父类的构造方法。

2.6 继承中构造方法的特点(父子类)

特点 ：
 构造方法不能被继承（构造方法是一个类独有的方法）
 创建子类对象一定是先调用父类构造，再调用子类构造。(并且只有子类构造才能调
用父类构造)。
 子类构造可以通过super关键字调用父类有参构造 无参super() 有参super(参数列
表) 。
 super父类构造调用，必须是子类构造中的第一行语句。(并且一个子类构造，只能
调用一次super())。必须先有父再有子。

public class Fu {
	//钱
	int money = 500;
	//姓氏
	String xingshi;
	//有参构造
	public Fu(String xingshi){
		this.xingshi=xingshi;
	}
	//自我介绍
	public void introduce(){
		System.out.println("本人姓"+xingshi);
	}
	// public Fu(){
	// 	System.out.println("调用了Fu父类的构造方法");
	// }
}
public class Zi extends Fu{
	//在继承关系中的构造特点（满足先有父，再有子原则）:
	//1.子类的构造会默认调用父类的无参构造，以满足先有父再有子的原则。
	//2.当父类没有无参构造，只有有参构造的时候，我们需要在子类构造的
	// 第一行代码处，使用super关键字显示调用父类构造
	public Zi(){
		//在子类构造的第一行代码处，显示调用父类构造
		super("张");
		System.out.println("调用了Zi的构造方法");
	}
	public Zi(String xingshi){
		super(xingshi);
	}
}
public static void main(String[] args) {
	//创建子类对象
	//Zi zi = new Zi();
	//System.out.println("儿子的钱:"+zi.money);
	//创建子类对象
	//new Zi();
	//创建子类
	Zi z = new Zi();
	z.introduce();
	Zi z2 =new Zi("李");
	z2.introduce();
}

继承的特点： java中类与类之间是单继承的。但是可以多级继承。一个父类可以有多个子类。

2.7 Object类

Object是所有类的父类，任何类都默认继承Object
理论上Object类是所有类的父类，即直接或间接的继承java.lang.Object类。由于所有的类都继承在Object类，因此省略了extends Object关键字。
该类中主要有以下方法: toString(),getClass(),equals(),clone(),finalize(), 其中
toString(),getClass(),equals()是其中最重要的方法。
注意：
Object类中的getClass(),notify(),notifyAll(),wait()等方法被定义为final类型，因此不能重写。
equals()方法 在比较字符串时 比较的是俩个字符串的值。但是实际上equals方法比较的是地址值。
为什么String就可以用equals()比较值呢？

因为String类中重写了equals()方法,所以可以比较值。

什么样的类可以构成继承关系？
如果两个类之间符合is-a(是一个)描述，
则这两个就具有继承关系
苹果是一个水果: 苹果类 继承 水果类
宝马车是一个车：宝马车 继承 车类
张三是一个人 : 张三 继承 人类
继承实例:学生管理系统，通过继承实现代码复用
学生和老师有一些共同属性。有相同的方法。通过继承人类实现代码复用

package com.test4;
public class People {
	String name;
	String sex;
	public People(String name,String sex){
		this.name=name;
		this.sex=sex;
	}
	public void show(){
	System.out.println(this.name+" "+this.sex);
	}
}

package com.test4;
public class Student extends People{
	public Student(String name,String sex){
		super(name,sex);
	}
}

package com.test4;
public class Teacher extends People{
	String edu;
	String pos;
	public Teacher(String name,String sex,String edu,String pos){
		super(name,sex);
		this.edu=edu;
		this.pos=pos;
	}
	public void show(){
		super.show();
		System.out.println(this.edu+" "+this.pos);
	}
}

package com.test4;
public class Test {
	public static void main(String[] args) {
		Student s=new Student("张三","男");
		s.show();
		Teacher t=new Teacher("王老师","女","博士","教授");
		t.show();
	}
}

小结

1. 继承关键字：extends
2. 单继承，一个类只能有一个直接父类
3. 子类可以继承父类：public protected 同包默认的属性和方法，不能继承private私
   有方法
4. 子类可以书写自己的属性和方法
5. 子类可以重写父类的方法
6. 在子类中可以通过super调用父类的方法和属性。super.方法名/属性名

无父无子：

a. 父类构造不能继承，但是必须调用
b. new子类的时候，子类构造的第一行必须调用父类的构造方法
c.如果子类不写super()，系统默认调用父类无参构造
d.可以通过super(参数)调用有参，并且必须第一行，并且只能有一个super()。
如果通过子类调用方法，优先调用自己的方法。子类重写方法之后调用自己的方法，如果子类没有重写方法则使用父类的方法。

1. 先子类—》再父类—》再父类–》。。。。–》Object
2. 所有类都直接或者间接的继承了Object类。Object是所有类的基类,超类。

继承的作用：

A. 减少代码冗余
B. 书写一个父类，子类可以对父类进行扩展
C. 子类可以对父类重新定义

第三节 final关键字

final 代表最终的，不可改变的。
字符串为什么是不可变的？因为String类是用final关键字修饰的。
三种用法：
 可以用来修饰类
final修饰的类不能被继承，也就意味着这个类其中的方法不能被重写。
 可以用来修饰方法
final关键字修饰的方法不能被覆盖重写。表示一个最终的方法。
 可以用来修饰变量
final修饰成员变量—》常量 命名必须全大写 一般多个单词使用下划线连接
D_AGE,CAT_AGE, PI
基本数据类型：使用final修饰的基本数据类型值不能变，并且只能被赋值一次。
引用数据类型：使用final修饰的引用类型，引用的地址值不能改变，但是对象的属性值可以改变。
 对于成员变量来说，使用final 修饰照样是不可变的，但是因为成员变量有默认值，所以必须手动赋值。
 对final修饰的成员变量来说，可以直接赋值，也可以通过构造方法赋值，但是必须二选一。
 如果要通过构造方法赋值，并且类中有多个构造方法，必须保证每一个构造方法都要对final修饰的成员变量赋值。

//final修饰类，不允许被继承
public class MyCls {
	//用final修饰的变量，称为常量。常量必须被赋值，而且一旦赋值就不能改变。
	private final String str = "aaa";
	//静态常量
	private static final String str2 ="bbb";
	//final修饰方法，改方法不能被重写
	public final void test(){
		//this.str="bbb";
	}
}
public class Student {
	String name;
	int age;
}
public class Test {
	public static void main(String[] args) {
		//局部常量，允许先定义再赋值。但是一旦赋值就不能改变
		final int a;
		a = 20;
		//a = 30;
		final Student s = new Student();
		s.name="张三";
		s.age = 20;
		s.name="李四";
		s.age = 18;
	}
}

第四节：基本类型(四类八种)包装类

4.1 概念

基本数据类型使用非常方便，但是我们没有对应的方法去操作它们，可以通过一个类把基本数据类型包装起来，在类中定义一些方法，这个类就叫包装类。我们可以使用包装类中定义的方法去操作基本数据。
基本数据类型和对应的包装类：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

4.2 自动装箱与自动拆箱

 装箱
基本数据类型转换成包装类
 拆箱
包装类转换成基本数据类型

4.3 基本数据类型与字符串之间的转换

 基本类型（数字）----》字符串(String)

1. 可以使用数字直接+空字符串
    例如： String a = 5 + “”;
2. 使用Integer包装类的方法 toString(int i);
    例如: String a = Integer.toString(100);
3. 使用String类的方法valueOf(int i)
    例如：String a = String.valueOf(100);
    字符串----》基本数据类型（数字）
   注意：只有数字类型的字符串，才可以转换成数字
   使用包装类的方法xxx.parseXXX(“5”); NumberFormatException 数字格式异常

public static void main(String[] args) {
	//整形的基本类型
	int n1 = 10;
	//整形的对象类型(包装类)
	Integer n2 = 20;
	//将对象类型赋值给基本类型，拆箱(还原本质)
	//n1 = n2;
	//讲基本类型赋值给对象类型，装箱(进行包装)
	n2 = n1;
	//System.out.println(n1+n2);
	//对象类型和基本类型区别：
	//1.对象类型除了能实现基本类型的数据功能，还有额外的属性和方法
	//2.对象类型可以赋值为null，基本类型不可以
	//3.对象类型和对应的基本类型可以相互赋值(jdk高版本1.8)
	System.out.println(Integer.MAX_VALUE); //整形的最大值
	System.out.println(Integer.MIN_VALUE); //整形的最小值
	String s = Integer.toString(100); //讲整数转为字符串
	int x = Integer.valueOf("223"); //讲字符串转为整数
	int x2 = Integer.parseInt("234");
	int y = Integer.max(100,200); //取出两个数的最大值
	System.out.println(y);
	Integer z = null; //对象类型可以为null
	//int c = null; //基本类型不能为null
}
public static void main(String[] args) {
	//基本类型的小数
	double d1 = 10.234;
	//对象类型的小数
	Double d2 = 2.234;
	//d1 = d2;
	d2 = d1;
	System.out.println(Double.MIN_VALUE);
	System.out.println(Double.MAX_VALUE);
	double d3 = Double.valueOf("2.234");
	double d4 = Double.parseDouble("4.23");
	System.out.println(d3);
	System.out.println(d4);
	Double d5 = null;
	//double d6 = null;
	//用new的方式创建Double对象
	Double d = new Double(2.234);
	System.out.println(d.intValue()); //获取整形部分的数据
	System.out.println(d.doubleValue()); //完整的小数数据
}

面试题:

Integer的缓存

public static void main(String[] args) {
	Integer i1 = new Integer(100);
	Integer i2 = new Integer(100);
	//System.out.println(i1==i2); //比较数据地址
	//System.out.println(i1.equals(i2)); //比较内容
	Integer i3 = Integer.valueOf(1000);
	Integer i4 = 1000;
	System.out.println(i3==i4);
	System.out.println(i3.equals(i4));
}

作业

1.定义打印机类，学生类，老师类
打印机中定义重载方法，可以打印学生的信息和老师的信息

public class Student{
	...
}
public class Teacher{
	...
}
public class Print{
	public void print(Student s){

	}
	public void print(Teacher t){
	
	}
}

2.定义宠物类，猫类和狗类
属性:名字，健康值
行为/方法:吃
实现继承关系，并且重写吃的方法，猫吃小鱼，狗吃骨头
3.

4.

// A code block
var foo = 'bar';