Java第七章总结（面向对象核心技术）
目录
7.1 类的封装
7.2 类的继承
7.2.1 extends关键字
7.2.2 方法的重写
7.2.3 所有类的父类 —— Object 类
7.3 类的多态
7.3.1 方法的重载
7.3.2 向上转型
7.3.3 向下转型
7.3.4 instanceof 关键字
7.4 抽象类与接口
7.4.1 抽象类与抽象方法
7.4.2 接口的申明与实现
7.4.3 多重继承
7.4.4 区分抽象类与接口
7.5 访问控制
7.5.1 访问控制符
7.5.2 Java 类包
7.5.3 final 关键字
7.6 内部类
7.6.1 成员内部类
7.6.2 局部内部类
7.6.3 匿名内部类
7.6.4 静态内部类
7.6.5 内部类的继承
7.1 类的封装
7.2 类的继承
7.2.1 extends关键字
7.2.2 方法的重写
7.2.3 所有类的父类 —— Object 类
7.3 类的多态
7.3.1 方法的重载
7.3.2 向上转型
7.3.3 向下转型
7.3.4 dinstanceof 关键字
7.4 抽象类与接口
7.4.1 抽象类与抽象方法
7.4.2 接口的申明与实现
7.4.3 多重继承
7.4.4 区分抽象类与接口
7.5 访问控制
7.5.1 访问控制符
7.5.2 Java 类包
7.5.3 final 关键字
7.6 内部类
7.6.1 成员内部类
7.6.2 局部内部类
7.6.3 匿名内部类
7.6.4 静态内部类
7.6.5 内部类的继承
先复习一下： * 封装 就是面向编程的核心思想，将对象的属性和行为封装起来，其载体就是类。
import java.util Arrays;
/*
面向过程：当需要实现一个功能的时候，每一个具体步骤都要亲历亲为，详细处理每一细节齾。
面向对象：当需要实现一个功能的时候，不关心具体步骤，而是找一个已经具有该功能的人，来帮我做事。
*/
public class Demo09PrintArray {
public static void main(String[] args) {
int[] array = {10,20,30,40,50,60};
//要求打印格式为：[10,20,30,40,50]
//使用面向对象，每一个过程都要亲历亲为。
System.out.print("[");
for (int i = 0; i < array.length;i++);
if (i == array.length - 1) { //如果是最后一个元素
System.out.println(array[i] +"]");
}
}
System.out.println("==============================");
//使用面向对象
//找一个JDK给我们提供好的Arrays类
//其中有一个toString方法，直接就能把数组变成想要的格式的字符串
System.out.println(Arrays.toString(array)); (加上60也不影响结果)
}
}
面向过程和面向对象的区别在于：它区别于面向过程思想，强调的是通过阅读调用对象的行为来实现功能，而不是自己一步一步的去操作实现。
举栗子（简称人类偷懒行为）：
洗衣服：
- 面向过程：把衣服脱下来->找一个盆->放点洗衣粉->加点水->浸泡10分钟->揉一揉->清洗衣服->拧干->晾起来
*面向对象：把衣服脱下来->打开全自动洗衣机->扔衣服->按钮->晾起来
区别： 面向对象：强调步骤。 面向对象：强调对象，这里的对象是洗衣机。
特点：面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了 指挥者 。面向对象的语言中，包含了三大基本特征，即封装，继承和多态。
类和对象 ：环顾四周，你会发现很多对象，比如桌子，椅子，同学，老师等。桌椅属于办公用品，师生都是人类。
*类：是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
现实中，描述一类事物：
- 属性：就是该事物的状态信息。 * 行为：就是该事物能做什么。
举栗：小猫。 属性：名字，体重，年龄，颜色。
行为：走，跑，跳，叫。
类和对象的关系：
7.1 类的封装
通过解读栗子来理解封装，eg:我们到一个餐馆去吃饭，点了一盘鱼香肉丝，感觉好吃，我想知道厨师的名字，希望厨师多帮我做点儿事。
如果这个场景用Java代码毫无封装的实现，就是这样的：
public class Restaurant1 {
public static viod main(String[] args) {
String cookName="Tom Cruise"; //厨师的名字叫Tom Cruise
System.out.println("**请厨师为我做一份香辣肉丝。***");
System.out.println(cookName + "加葱花");
System.out.println(cookName + "洗蔬菜");
System.out.println(cookName + "开始烹饪" + "香辣肉丝");
System.out.println( "请问厨师叫什么名字？***");
System.out.println(cookName)
System.out.println( "**请厨师给我切一点葱花。***");
System.out.println(cookName + "切葱花");
此例子里面，所有逻辑代码全是在main方法中实现的，代码完全暴露，我们可以任意删改。如果可以任意删改，餐馆便无法正常运行，比如：我们知道餐馆的任何信息 ；我让厨师切葱花，出厨师却搅拌鸡蛋；我让厨师做一份清蒸鱼，厨师却让我唱首歌.........
System.out.println("**请让厨师给我切一点葱花。***");
System.out.println("cookName + "搅鸡蛋");
System.out.println("**请让厨师为我做一份清蒸鱼。***");
System.out.println("cookName + "你是我的小呀小苹果***");如何防止其他人修改厨师的行为呢？就是将厨师打包成类。
将厨师封装成Cook类，是想餐馆点菜的场景。
将厨师单独封装成一个类，将厨师定义成厨师类的行为，当我们想让厨师做菜，只能通过调用对象成员方法实现，而我们却不知道这个方法到底怎么写，所以无法随意修改。餐馆没有义务告诉我们厨师的任何信息，并且厨师也不会随意受我们差遣，所以说厨师的有些属性和行为不予以公开。
我们将厨师的属性和部分方法用private来修饰。re
此时再运行餐馆的主方法，就会抛出异常，提示Cook2的name和cutOnion()不可以直接调用。
日常生活中，顾客根本没有接触厨师的机会，所以厨师这个角色是对顾客来说是隐蔽的，被封装在餐馆的类当中。
将厨师对象封装在餐馆类中，顾客无法接触厨师的任何信息。
public class Restaurant {
private Cook2 cook = new Cook2 (); //餐厅封装的厨师类
public static void takeOrder (String dish) { //下单
cook.cooking(dish); //通知厨师做菜
System.out.println("您的菜好了，请慢用。");
}
public String saySorry() {//拒绝客户要求
return "抱歉，餐厅不提供此项服务。";
}
public static void main(String[] args) {
Restaurant waiter = new Restaurant();//创建餐厅对象，为顾客提供服务
System.out.println("**请厨师为我做一份鱼香肉丝。***");
waiter.takeOrder("鱼香肉丝");//服务员给顾客下单
System.out.println("**你们厨师叫什么名字？***");
System.out.println(waiter.saySorry());//服务员给顾客善意的答复
System.out.println("**请厨师给我切一点葱花。***");
System.out.println(waiter.saySorry());//服务员给顾客善意的答复
}
}此例可得，作为顾客是始终和厨师没有交集的，只能是由服务员来传达，作为顾客不知道美食由那位厨师又或是字母烹饪出来的**，这种编程模式就是封装。**
封装的思想：将对象的属性和行为封装起来的载体就是类。类通常对客户隐藏其实现细节。
7.2 类的继承
继承在面向对象开发思想中是一个非常重要的概念，它使整个程序架构具有一定的弹性，在程序中复用已经定义完善的类不仅可以减少软件开发周期，还可以提高软件的可维护性和可拓展性。
举两个栗子：1 、平行四边形是特殊的四边形，可以说平行四边形继承了四边形类，这时平行四边形类将所有四边形具有的属性和方法都保留下来，并基于四边形类扩展了一些新的平行四边形类特有的属性和方法。
2、
eg:
Person类：
class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name ;
}
public void setAge(int age) {
this.age = age;
}
public String getname() {
return this .name;
public int getAge() {
return this.age;
}
}Students类：
class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name ;
}
public void setAge(int age) {
this.age = age;
}
public String Setschool(String school) {
this.school = school;
public String getname() {
return this .name;
}
public int getAge() {
return this.age;
}
public String getSchool() {
return this.school;
}
}多态性特征：
7.2.1 extends关键字
在Java中，让一个类继承另一个类，用extends关键字，语法如下：
child extends parents这里child这个类作为子类继承了parents这个类，并继承parents中的属性和方法。
举一个栗子：
最常见的是台式计算机，后来变得越来越小，台式变为可移动笔记本，又变成了更轻薄本平板电脑。即可把普通计算机看成一个类，那么笔记本和平板电脑都是这个类衍生出类的子类。
注意：
Java类只支持单继承，即一个子类只能继承一个父类，类似于下面的代码是错误的：
child extends parents1，parents2 { //错误的继承语法
}通过这个栗子来理解extends关键字：
public class Rich1st2 extends Rich {
..........
}理解为富一代类继承了富人类，注意类名后面的extends关键字，Java中使用entends关键字表示
富一代还扩展出自己的特殊属性和方法（上面的Person类和Students类之间的关系也是同理）。
7.2.2 方法的重写
/** * 把父类里面定义的公共的方法拿过来
* 重写一遍方法体内容
*方法的重写：把父类定义的方法拿到具体子类重新填上方法体
*/
@Override //表示覆盖了父类的move方法，即方法的重写
public void move() {
System.out.pritnln("我是" + this.type+"我能飞跃太平洋");
}
} /** * 父类定义的方法遵循共同的原则
*车的移动方法
*当子类覆盖、重写父类的方法的定义
*父类的方法仅需要提供方法的概念
*/
方法的重写或方法的覆盖（overriding)
子类根据需求从父类继承的方法进行重新编写
重写时，可以用super.方法来保留父类的方法
构造方法不能被重写，只有普通方法才能够被覆盖。2、super 关键字
super关键字的使用方法与this关键字类似
super.property; //调用父类的属性
super.method(); //调用父类的方法
7.2.3 所有类的父类 —— Object 类
java.lang.Object类的说明
*1. Object 类是所有Java类的根父类
*2. 如果在类的声明中未使用extends关键字指明其父类，则默认父类为Java.lang.Object类
*3. Object 类中的功能（属性、方法）就具有通用性。
*属性： 无
*方法： equals()、toString()、getClass()、hashCode()、clone()、finalize()、wait()、notfy()、notfyAll();
**注意:Object类中的getclass()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。
*4. Object类只声明了一个空参数的构造器所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。
1、getClass()方法
getClass().getName();2、toString()方法
功能：将一个对象返回为字符串形式，它会返回一个String实例。为对象提供一个特定的输出模式。
3、equals()方法
前面所学equals（）方法，当时是比较“==”运算符与equals（）方法，说明“==”比较的是前面两个对象的引用是否相等，而equals（）方法比较的是两个对象的实际内容，通过例子来理解。
eg: 在项目中创建*类，在类的主方法中定义两个字符串对象，调用equals（）方法判断两个字符串对象是否相等。
7.3 类的多态
在程序设计语言中，多态性是指“一种定义，多种实现”，eg: 运算符“+”作用于两个整型量时时求和，而作用于两个字符量时则是将其连接在一起。利用多态可以使程序具有良好的拓展性，并可以对所有类对象进行通用处理。类的多态的两方面体现：一是方法的重载。二是类的上下转型。（通过上图栗子理解）
7.3.1 方法的重载
eg:在类中编写多个重载形式，然后在主方法中分别输出这些方法返回值.
多学两招：
重载和重写都体现了面向对象的多态性，但重载与重写是完全两个不同的概念，重载主要用于一个类内实现若干重载的方法，这些方法的名称相同而参数形势不同；而重写主要用于子类继承父类时，重新实现父类中的非私有方法。
7.3.2 向上转型
7.3.3 向下转型（向上和向下转型及instanceof关键字一起理解）
7.3.4 instanceof 关键字
Animal animal = new Animal();
等号左边是类型声明，等号右边是对象实例，此时等号两侧都是同一类型
**变换后：**Animal animal 1 = new Dog();
Animal animal 2 = new Cat();
改为等号左边的子类，这种将子类对象赋值给父类类型的操作就是向上转型，也就是我们常说的父类引用子类的对象，因为符号is-a原则，所以没有问题。但是在日常开发中我们会使用大量的向上转型
除了上面的显示复制外很多时候会默认发生向上转型，如下：
比如我们将参数声明为父类，别人在传参时传的是子类对象，这也属于向上转型
public static void shower(Animal animal) {
// ......
}
public static void main(String[] args) {
shower(new Dog（)）；
shower(new Cat（)）；
}
而向下转型（downcasting）:
Animal animal = new Dog();
Dog dog = animal; // 编译出错，此时animal代表父类实例
： 就是反过来将父类对象实例赋值给子类的声明，当然直接这样做肯定会编译报错，因为不符合is-a原则，所以我们必须要加一个括号，这个括号的作用就是将对象强制转换成指定类型，
Animal animal = new Dog()
Dog dog = (Dog) animal;
Cat cat = (Cat) animal; //运行时出错，因为Dog不是Cat
强制类型转换虽然可以通过编译，但也有可能在运行时转换失败从而抛出异常，所以为了保证向下转型成功,我们可以通过instansof操作符来判断对象实例是否属于某种类型，不过每次都要判断再强转类型就显得代码重复和繁琐，所以就提供了更简洁的方法，可在判insanceof后直接声明变量：
Aniamal animal = new Dog();
if (animal instanceof Dog) {
Dog dog = （Dog) animal;
dog.xxx();
}
if （animal instanceof Cat cat) {
cat.xxx();
}
7.4 抽象类与接口
抽象类更进一步抽象后就诞生了接口，接口比抽象类更纯粹，因为它没有了成员属性，只有方法，子类实现接口后唯一做的就是重写方法，不想抽象类，子类继承抽象类之后连带将父类的成员属性也继承过来了这里也是他们的 第三个差异点，抽象类可以定义成员属性，而接口不能成员属性，这能定义静态属性，而且只能用final定义静态常量，不能定义静态变量接口除了没有成员属性外外，还没有构造器（接口就是只有方法和静态常量的类）
public abstract class Animal {
protected String name;
public abstract void eat();
}
public interface Runable {
public static final String CRAB = "螃蟹";
public abstract void run();
}抽象类不能被使用，但是他的构造器的作用是限定子类的构造行为，比如抽象类可以用构造器定义好几个参数，子类要想实例化则必须想办法传入这几个参数才行。
public abstract class Aniaml {
protected String name;
protected Animal(String name) {
this.name = name;
}
public abstract void eat();
}
class Dog extends Animal {
public Dog (String name) {
super(name);
}
@Override
public void eat() {
System.out.println(name + " 要开吃了 **");
}
}
额外讲解： 一些重要的版本差异，其实在Java 8 之前更加纯粹，当时的接口只能定义抽象方法，不能自己实现方法，也不能定义静态变量，到了Java8才可以定义静态方法，以及可用default关键字来实现方法，因为ava8新增加了许多原有特性，这些特性会影响到之前的子类如果继承了某个接口，突然接口新增加了一个方法，你的子类就会编译失败，为了保证向下兼容性才推出了default关键字，被default关键字修饰的方法就不是抽象方法了，也不会强制要求已有的子类去实现方法，default方法出现后，有了这个便利，大家就大量在接口中趋实现一些默认逻辑，但使用复杂逻辑会导致代码难以维护，于是Java9又推出了新特性就是卡可以定义private方法这样就可以将内部逻辑拆开，这样导致内部差异越小；什么时候用抽象类和接口，当需要让子类继承成员变量或者需要控制子类实例化时用抽象类·，否则用接口；
抽象类 接口
定义 包含抽象方法的类 主要是抽象方法的静态常量的类
组成 构造器 静态常量
抽象方法 抽象方法
普通成员方法 成员变量 default 方法 静态方法（Java8）
静态方法 静态方法 私有方法
常量
使用 子类继承抽象类 子类实现接口
关系 子类只继承一个抽象类 子类只继承一个抽象类
抽象类可以实现多个接口 接口不能继承类 但可以继承多个接口
选择 如果需要继承父类的成员变量，或者需要控制子类的实例化，则选择抽象类；优先选择接口，避免单继承的局限
public interface Runnable {
void run ();
default void defaultMethod() {
System.out.println("default 方法");
}
static void staticMethod() {
System.out.println("静态方法”）；
}
}
public abstract class Animal {
public abstract void eat();
}
public interface Runnalbe {
public abstract void run();
}
抽象类与接口都是为了将方法进行抽象，然后让子类去实现 ，所以可以定义一个抽象方法它们的第一个相同点；
这种父类没有必要创建实例对象，所以它们的第二个相同点就是不能创建本类对象只能有子类去实例化子类对象；两则罪名相对差异点就是子类要扩展它们时，对抽象类使用的是extends关键字，我们称之为继承；接口用的是implements关键字，我们称之为实现，之只是关键这关键字和称呼不同，本质都一样如下：
//继承抽象类
public class Dog extends Animal{ }
//实现接口
public class Thread implements Runnable { }
然后，抽象类可以去继承接口，接口只能继承接口，不能继承类；如下:
public abstract class Aniaml implements A {
}
public interface Runnable extends A, B,C {
}
同时一个类最多只能继承一个父类，但可以实现多个接口,所以当我们发现既可以用抽象类，也可以用接口时，尽量去选择接口，这样子类的灵活度更高
public abstract class Pet extends Animal implements A,B,C {
}
7.4.1 抽象类与抽象方法
7.4.2 接口的申明与实现
7.4.3 多重继承
通过接口实现多重继承的语法如下：
class 类名 implements 接口1，接口2，...，接口n
通过类实现多个接口模拟家庭成员的继承关系。
public interface IFather { //定义一个接口
void smoking(); //抽烟的方法
void goFishing(); //钓鱼的方法
}
定义一个IMother接口，并在其中定义两个方法wacthTV和cooking,代码如下：
public interface IMother { //定义一个接口
void wacthTV()； //看电视的方法
void cooking(); //做饭的方法
创建名称为Me类，继承IFather和IMother两个接口
public class Me implements IFather, IMother { //继承IFather接口和IMother接口
public void wacthTV() { //重写wacthTV()方法
System.out.println("我喜欢看电视");
}
public void cooking() { //重写cooking()方法
System.out.println("我喜欢做饭");
}
public void smoking() { //重写smoking()方法
System.out.println("我喜欢抽烟");
}
public void goFishing() { //重写goFishing()方法
System.out.println("我喜欢钓鱼");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
IFather fater = new Me(); //通过子类创建IFather接口对象
System.out.println("爸爸的爱好:");
father.smoking(); //使用接口对象调用子类中实现的方法
father.goFishing();
Mother mater = new Me(); //通过子类创建IMother接口对象
System.out.println("\n妈妈的爱好:");
mather.cooking(); //使用接口对象调用子类中实现的方法
mather.wacthTV();
}
}7.4.4 区分抽象类与接口（上面7.4详解）
7.5 访问控制
7.5.1 访问控制符
所有访问控制符时，需要遵循以下原则。
（1）大部分顶级类都使用public修饰。
（2）如果某个类主要用作其他类的父类，该类中包含的大部分方法只是希望被其子类重写，而不想被外界直接调用，则应该使用protected修饰。
（3）类中的绝大部分属性都应该使用private修饰，除非一些static或者类似全局变量的属性，才会考虑使用public修饰；
（4）当定义的方法只是用于辅助实现该类的其他方法，应该使用private修饰；
（5）希望允许其他类自由调用的方法应该使用public修饰。
7.5.2 Java 类包
在Java中采用类包机制非常重要，类包不仅可以解决类名冲突问题，还可以在开发庞大的应用程序时，帮助开发人员管理庞大的应用程序组件，方便软件复用。
在类中定义包名的语法如下：
package 包名1 [.包名2[.包名3...] ];
注意：Java包的命名规则是全部使用小写字母，另外，由于包名将转换为文件的名称，所以包名不包括特殊字符
使用包中的类，其语法如下：
import 包名1 [.包名2[.包名3...] ].类名；
import com.lzw.*; //指定 com.lzw包中的所有类在程序中都可以使用
import com.lzw.Math ///指定 com.lzw包中的Math类在程序中可以使用
7.5.3 final 关键字
1.final类
定义为final的类不能被继承
final的语法如下:
final class 类名{ }
2.final 方法
final方法不能被覆盖，定义一个为private的方法隐式被指定为final类型，这样无需将一个定义为private的方法再定义为final类型，例如下面：
private final void test() {undefined
...//省略一些程序代码
}
3、final 变量
final 关键字可用于变量声明（定义的变量必须在声明时对其进行赋值操作） ，一旦该变量被设定，就不可以再改变该变量的值。
final double PI=3.14;
7.6 内部类
7.6.1 成员内部类
成员内部类介绍
在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。
在内部类中可以随意使用外部类的成员方法以及成员变量。
成员内部类的语法如下：
public class OuterClass { //外部类
private class InnerClass { //内部类
//...
}
}
例如，在主方法中实例化一个内部类对象。
public class void main(String args[]) {undefined
OuterClass out = new OuterClass();
OuterClass.innerClass in =out.doit();
OuterClass.innerClass in2=out.new innerClass(); //实例化内部类对象
3、使用this关键字获取内部类与外部类的引用
如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字。
使用成员内部类时，应该遵循以下原则：
（1）可以有各种修饰符，可以用private、public、protectd、static、final 、abstract等修饰符。
（2）如果有内部类有static限定，就是类级别的，否则为对象级别.类级别可以通过外部类直接访问，对象级别需要先生成外部类的对象后才能访问；
（3）内部类不能同名；
（4）非静态内部类中不能声明任何static成员；
（5）内部类可以互相调用；
public class TheSameName {
private int x;
private class Inner {
private int x = 9;
public void doit (int_x) {
x++; //调用的是形参x
this.x++; //调用内部类的变量x
TheSameName.this.x++; //调用外部类的变量x
}
}
}7.6.2 局部内部类
局部类不仅可以在类中进行定义，也可以在类的局部位置定义，如在类的方法或任意的作用域中均可以定义内部类。
interface OutInterface2 {
}
class OuterClass3 {
public OutInterface2 doit (final String x) { //doit()方法参数为final类型
//在doit()方法中定义一个内部类
class InnerClass2 implements OutInterface2 {
InnerClass2(String s) {
s = x;
System.out.println(s);
}
}
return new InnerClass2("doit");
}
}7.6.3 匿名内部类
匿名类所有实现代码都需要在大括号之间进行编写。语法如下：
return new A() { //A指类名
...//内部类体
}；
使用匿名内部类时应该以下原则：
（1）匿名类没有构造方法
（2）匿名类不能定义静态的成员
（3）匿名类不能用private、public、protectd、static、final 、abstract等修饰
（4）只可以创建一个匿名类实例
7.6.4 静态内部类
在内部类前添加修饰符static ,这个内部类就变为静态内部类了。
静态内部类具有以下两个特点：
（1）如果创建静态内部类的对象，不需要创建其外部类的对象；
（2）不能从静态内部类的对象中访问非静态外部类的对
public class StaticInnerClass {
int x = 100;
static class Inner {
void doitInner() {
//System.out.prinln("外部类"+x); //不能调用外部类的成员变量x
}
}
}
在静态内部类中定义主方法
+ public static void main(String args[]) {
System.out.prinln();7.6.5 内部类的继承
内部类和其他普通类一样可以被继承，但是继承内部类比继承普通类复杂，需要设置专门的语法来完成。
public class OutputInnerClass extends ClassA.ClassB {
public OutputInnerClass(ClassA a) {
a.super();
}
}
class ClassA {
class ClassB {
}
}在某个类继承内部类时，必须硬性给予这个类带参数的构造方法，并且该构造方法的参数必须是该内部类的外部类引用。