第一章 抽象类
1.1 概述
1.1.1 抽象类引入
父类中的办法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的办法申明和办法主体，只有申明还有意义，而办法主体则没有存在的意义了(因为子类对象会调用本人重写的办法)。换句话说，父类可能晓得子类应该有哪个性能，然而性能具体怎么实现父类是不分明的（由子类本人决定），父类只须要提供一个没有办法体的定义即可，具体实现交给子类本人去实现。咱们把没有办法体的办法称为形象办法。Java语法规定，蕴含形象办法的类就是抽象类。
- 形象办法 ： 没有办法体的办法。
- 抽象类：蕴含形象办法的类。
1.2 abstract应用格局
abstract是形象的意思，用于润饰办法办法和类，润饰的办法是形象办法，润饰的类是抽象类。
1.2.1 形象办法
应用abstract 关键字润饰办法，该办法就成了形象办法，形象办法只蕴含一个办法名，而没有办法体。
定义格局：
修饰符 abstract 返回值类型 办法名 (参数列表)；代码举例：
public abstract void run()；1.2.2 抽象类
如果一个类蕴含形象办法，那么该类必须是抽象类。留神：抽象类不肯定有形象办法，然而有形象办法的类必须定义成抽象类。
定义格局：
abstract class 类名字 { }代码举例：
public abstract class Animal { public abstract void run()；}1.2.3 抽象类的应用
要求：继承抽象类的子类必须重写父类所有的形象办法。否则，该子类也必须申明为抽象类。
代码举例：
// 父类,抽象类abstract class Employee { private String id; private String name; private double salary; public Employee() { } public Employee(String id, String name, double salary) { this.id = id; this.name = name; this.salary = salary; } // 形象办法 // 形象办法必须要放在抽象类中 abstract public void work();}// 定义一个子类继承抽象类class Manager extends Employee { public Manager() { } public Manager(String id, String name, double salary) { super(id, name, salary); } // 2.重写父类的形象办法 @Override public void work() { System.out.println("治理其他人"); }}// 定义一个子类继承抽象类class Cook extends Employee { public Cook() { } public Cook(String id, String name, double salary) { super(id, name, salary); } @Override public void work() { System.out.println("厨师炒菜多加点盐..."); }}// 测试类public class Demo10 { public static void main(String[] args) { // 创立抽象类,抽象类不能创建对象 // 假如抽象类让咱们创建对象,外面的形象办法没有办法体,无奈执行.所以不让咱们创建对象// Employee e = new Employee();// e.work(); // 3.创立子类 Manager m = new Manager(); m.work(); Cook c = new Cook("ap002", "库克", 1); c.work(); }}此时的办法重写，是子类对父类形象办法的实现实现，咱们将这种办法重写的操作，也叫做实现办法。
1.3 抽象类的特色
抽象类的特色总结起来能够说是 有得有失
有得：抽象类失去了领有形象办法的能力。
有失：抽象类失去了创建对象的能力。
其余成员（构造方法，实例办法，静态方法等）抽象类都是具备的。
1.4 抽象类的细节
不须要背，只有当idea报错之后，晓得如何批改即可。
对于抽象类的应用，以下为语法上要留神的细节，尽管条目较多，但若了解了形象的实质，无需死记硬背。
抽象类不能创建对象，如果创立，编译无奈通过而报错。只能创立其非形象子类的对象。
了解：假如创立了抽象类的对象，调用形象的办法，而形象办法没有具体的办法体，没有意义。
抽象类中，能够有构造方法，是供子类创建对象时，初始化父类成员应用的。
了解：子类的构造方法中，有默认的super()，须要拜访父类构造方法。
抽象类中，不肯定蕴含形象办法，然而有形象办法的类必然是抽象类。
了解：未蕴含形象办法的抽象类，目标就是不想让调用者创立该类对象，通常用于某些非凡的类结构设计。
抽象类的子类，必须重写形象父类中所有的形象办法，否则子类也必须定义成抽象类，编译无奈通过而报错。
了解：假如不重写所有形象办法，则类中可能蕴含形象办法。那么创建对象后，调用形象的办法，没有意义。
抽象类存在的意义是为了被子类继承。
了解：抽象类中曾经实现的是模板中确定的成员，抽象类不确定如何实现的定义成形象办法，交给具体的子类去实现。
1.5 抽象类存在的意义
抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义。抽象类能够强制让子类，肯定要依照规定的格局进行重写。
第二章 接口
2.1 概述
咱们曾经学完了抽象类，抽象类中能够用形象办法，也能够有一般办法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的形象，JDK7之前，包含JDK7，接口中全副是形象办法。接口同样是不能创建对象的。
2.2 定义格局
//接口的定义格局：interface 接口名称{ // 形象办法}// 接口的申明：interface// 接口名称：首字母大写，满足“驼峰模式”2.3 接口成分的特点
在JDK7，包含JDK7之前，接口中的只有蕴含：形象办法和常量
2.3.1.形象办法
留神：接口中的形象办法默认会主动加上public abstract润饰程序员无需本人手写！！
依照标准：当前接口中的形象办法倡议不要写上public abstract。因为没有必要啊，默认会加上。
2.3.2 常量
在接口中定义的成员变量默认会加上： public static final润饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是应用public static final润饰后，变量值就不可被批改，并且是动态化的变量能够间接用接口名拜访，所以也叫常量。常量必须要给初始值。常量命名标准倡议字母全副大写，多个单词用下划线连贯。
2.3.3 案例演示
public interface InterF { // 形象办法！ // public abstract void run(); void run(); // public abstract String getName(); String getName(); // public abstract int add(int a , int b); int add(int a , int b); // 它的最终写法是： // public static final int AGE = 12 ; int AGE = 12; //常量 String SCHOOL_NAME = "黑马程序员";}2.4 根本的实现
2.4.1 实现接口的概述
类与接口的关系为实现关系，即类实现接口，该类能够称为接口的实现类，也能够称为接口的子类。实现的动作相似继承，格局相仿，只是关键字不同，实现应用 implements关键字。
2.4.2 实现接口的格局
/**接口的实现： 在Java中接口是被实现的，实现接口的类称为实现类。 实现类的格局:*/class 类名 implements 接口1,接口2,接口3...{}从下面格局能够看出，接口是能够被多实现的。大家能够想一想为什么呢？
2.4.3 类实现接口的要求和意义
- 必须重写实现的全副接口中所有形象办法。
- 如果一个类实现了接口，然而没有重写齐全部接口的全副形象办法，这个类也必须定义成抽象类。
- 意义：接口体现的是一种标准，接口对实现类是一种强制性的束缚，要么全副实现接口申明的性能，要么本人也定义成抽象类。这正是一种强制性的标准。
2.4.4 类与接口根本实现案例
如果咱们定义一个运动员的接口（标准），代码如下：
/** 接口：接口体现的是标准。 * */public interface SportMan { void run(); // 形象办法，跑步。 void law(); // 形象办法，恪守法律。 String compittion(String project); // 形象办法，较量。}接下来定义一个乒乓球运动员类，实现接口，实现接口的实现类代码如下：
package com.itheima._03接口的实现;/** * 接口的实现： * 在Java中接口是被实现的，实现接口的类称为实现类。 * 实现类的格局: * class 类名 implements 接口1,接口2,接口3...{ * * * } * */public class PingPongMan implements SportMan { @Override public void run() { System.out.println("乒乓球运动员略微跑一下！！"); } @Override public void law() { System.out.println("乒乓球运动员违法！"); } @Override public String compittion(String project) { return "加入"+project+"得金牌！"; }}测试代码：
public class TestMain { public static void main(String[] args) { // 创立实现类对象。 PingPongMan zjk = new PingPongMan(); zjk.run(); zjk.law(); System.out.println(zjk.compittion("寰球乒乓球较量")); }}2.4.5 类与接口的多实现案例
类与接口之间的关系是多实现的，一个类能够同时实现多个接口。
首先咱们先定义两个接口，代码如下：
/** 法律标准：接口*/public interface Law { void rule();}/** 这一个运动员的标准：接口*/public interface SportMan { void run();}而后定义一个实现类：
/** * Java中接口是能够被多实现的： * 一个类能够实现多个接口: Law, SportMan * * */public class JumpMan implements Law ,SportMan { @Override public void rule() { System.out.println("尊长违法"); } @Override public void run() { System.out.println("训练跑步！"); }}从下面能够看出类与接口之间是能够多实现的，咱们能够了解成实现多个标准，这是正当的。
2.5 接口与接口的多继承
Java中，接口与接口之间是能够多继承的：也就是一个接口能够同时继承多个接口。大家肯定要留神：
类与接口是实现关系
接口与接口是继承关系
接口继承接口就是把其余接口的形象办法与本接口进行了合并。
案例演示：
public interface Abc { void go(); void test();}/** 法律标准：接口*/public interface Law { void rule(); void test();} * * 总结： * 接口与类之间是多实现的。 * 接口与接口之间是多继承的。 * */public interface SportMan extends Law , Abc { void run();}2.6扩大：接口的细节
不须要背，只有当idea报错之后，晓得如何批改即可。
对于接口的应用，以下为语法上要留神的细节，尽管条目较多，但若了解了形象的实质，无需死记硬背。
- 当两个接口中存在雷同形象办法的时候，该怎么办？
只有重写一次即可。此时重写的办法，既示意重写1接口的，也示意重写2接口的。
- 实现类能不能继承A类的时候，同时实现其余接口呢？
继承的父类，就好比是亲爸爸一样
实现的接口，就好比是干爹一样
能够继承一个类的同时，再实现多个接口，只不过，要把接口外面所有的形象办法，全副实现。
- 实现类能不能继承一个抽象类的时候，同时实现其余接口呢？
实现类能够继承一个抽象类的同时，再实现其余多个接口，只不过要把外面所有的形象办法全副重写。
- 实现类Zi，实现了一个接口，还继承了一个Fu类。假如在接口中有一个办法，父类中也有一个雷同的办法。子类如何操作呢？
解决方法一：如果父类中的办法体，能满足以后业务的需要，在子类中能够不必重写。
解决方法二：如果父类中的办法体，不能满足以后业务的需要，须要在子类中重写。
- 如果一个接口中，有10个形象办法，然而我在实现类中，只须要用其中一个，该怎么办?
能够在接口跟实现类两头，新建一个两头类（适配器类）
让这个适配器类去实现接口，对接口外面的所有的办法做空重写。
让子类继承这个适配器类，想要用到哪个办法，就重写哪个办法。
因为两头类没有什么理论的意义，所以个别会把两头类定义为形象的，不让外界创建对象
第三章 外部类
3.1 概述
3.1.1 什么是外部类
将一个类A定义在另一个类B外面，外面的那个类A就称为外部类，B则称为外部类。能够把外部类了解成寄生，外部类了解成宿主。
3.1.2 什么时候应用外部类
一个事物外部还有一个独立的事物，外部的事物脱离内部的事物无奈独立应用
- 人外面有一颗心脏。
- 汽车外部有一个发动机。
- 为了实现更好的封装性。
3.2 外部类的分类
按定义的地位来分
- 成员外部内，类定义在了成员地位 (类中办法外称为成员地位，无static润饰的外部类)
- 动态外部类，类定义在了成员地位 (类中办法外称为成员地位，有static润饰的外部类)
- 部分外部类，类定义在办法内
- 匿名外部类，没有名字的外部类，能够在办法中，也能够在类中办法外。
3.3 成员外部类
成员外部类特点：
- 无static润饰的外部类，属于外部类对象的。
- 宿主：外部类对象。
外部类的应用格局：
外部类.外部类。 // 拜访外部类的类型都是用 外部类.外部类获取成员外部类对象的两种形式：
形式一：内部间接创立成员外部类的对象
外部类.外部类 变量 = new 外部类（）.new 外部类（）;形式二：在外部类中定义一个办法提供外部类的对象
案例演示
形式一：public class Test { public static void main(String[] args) { // 宿主：外部类对象。 // Outer out = new Outer(); // 创立外部类对象。 Outer.Inner oi = new Outer().new Inner(); oi.method(); }}class Outer { // 成员外部类，属于外部类对象的。 // 拓展：成员外部类不能定义动态成员。 public class Inner{ // 这外面的货色与类是齐全一样的。 public void method(){ System.out.println("外部类中的办法被调用了"); } }}形式二：public class Outer { String name; private class Inner{ static int a = 10; } public Inner getInstance(){ return new Inner(); }}public class Test { public static void main(String[] args) { Outer o = new Outer(); System.out.println(o.getInstance()); }}3.4 成员外部类的细节
编写成员外部类的留神点：
- 成员外部类能够被一些修饰符所润饰，比方： private，默认，protected，public，static等
- 在成员外部类外面，JDK16之前不能定义动态变量，JDK16开始才能够定义动态变量。
- 创立外部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。（请参见3.6节的内存图）
详解：
外部类被private润饰，外界无奈间接获取外部类的对象，只能通过3.3节中的形式二获取外部类的对象
被其余权限修饰符润饰的外部类个别用3.3节中的形式一间接获取外部类的对象
外部类被static润饰是成员外部类中的非凡状况，叫做动态外部类上面独自学习。
外部类如果想要拜访外部类的成员变量，外部类的变量必须用final润饰，JDK8以前必须手动写final，JDK8之后不须要手动写，JDK默认加上。
3.5 成员外部类面试题
请在?中央向上相应代码,以达到输入的内容
留神：外部类拜访外部类对象的格局是：外部类名.this
public class Test { public static void main(String[] args) { Outer.inner oi = new Outer().new inner(); oi.method(); }}class Outer { // 外部类 private int a = 30; // 在成员地位定义一个类 class inner { private int a = 20; public void method() { int a = 10; System.out.println(???); // 10 答案：a System.out.println(???); // 20 答案：this.a System.out.println(???); // 30 答案：Outer.this.a } }}3.6 成员外部类内存图
3.7 动态外部类
动态外部类特点：
- 动态外部类是一种非凡的成员外部类。
- 有static润饰，属于外部类自身的。
- 总结：动态外部类与其余类的用法齐全一样。只是拜访的时候须要加上外部类.外部类。
- 拓展1:动态外部类能够间接拜访外部类的动态成员。
- 拓展2:动态外部类不能够间接拜访外部类的非动态成员，如果要拜访须要创立外部类的对象。
- 拓展3:动态外部类中没有银行的Outer.this。
外部类的应用格局：
外部类.外部类。动态外部类对象的创立格局：
外部类.外部类 变量 = new 外部类.外部类结构器;调用办法的格局：
- 调用非静态方法的格局：先创建对象，用对象调用
- 调用静态方法的格局：外部类名.外部类名.办法名();
案例演示：
// 外部类：Outer01class Outer01{ private static String sc_name = "黑马程序"; // 外部类: Inner01 public static class Inner01{ // 这外面的货色与类是齐全一样的。 private String name; public Inner01(String name) { this.name = name; } public void showName(){ System.out.println(this.name); // 拓展:动态外部类能够间接拜访外部类的动态成员。 System.out.println(sc_name); } }}public class InnerClassDemo01 { public static void main(String[] args) { // 创立动态外部类对象。 // 外部类.外部类 变量 = new 外部类.外部类结构器; Outer01.Inner01 in = new Outer01.Inner01("张三"); in.showName(); }}3.8 部分外部类
- 部分外部类 ：定义在办法中的类。
定义格局:
class 外部类名 { 数据类型 变量名; 修饰符 返回值类型 办法名(参数列表) { // … class 外部类 { // 成员变量 // 成员办法 } }}3.9 匿名外部类【重点】
3.9.1 概述
匿名外部类 ：是外部类的简化写法。他是一个隐含了名字的外部类。开发中，最罕用到的外部类就是匿名外部类了。
3.9.2 格局
new 类名或者接口名() { 重写办法;};蕴含了：
- 继承或者实现关系
- 办法重写
- 创建对象
所以从语法上来讲，这个整体其实是匿名外部类对象
3.9.2 什么时候用到匿名外部类
实际上，如果咱们心愿定义一个只有应用一次的类，就可思考应用匿名外部类。匿名外部类的实质作用
是为了简化代码。
之前咱们应用接口时，仿佛得做如下几步操作：
- 定义子类
- 重写接口中的办法
- 创立子类对象
- 调用重写后的办法
interface Swim { public abstract void swimming();}// 1. 定义接口的实现类class Student implements Swim { // 2. 重写形象办法 @Override public void swimming() { System.out.println("狗刨式..."); }}public class Test { public static void main(String[] args) { // 3. 创立实现类对象 Student s = new Student(); // 4. 调用办法 s.swimming(); }}咱们的目标，最终只是为了调用办法，那么能不能简化一下，把以上四步合成一步呢？匿名外部类就是做这样的快捷方式。
3.9.3 匿名外部类前提和格局
匿名外部类必须继承一个父类或者实现一个父接口。
匿名外部类格局
new 父类名或者接口名(){ // 办法重写 @Override public void method() { // 执行语句 }};3.9.4 应用形式
以接口为例，匿名外部类的应用，代码如下：
interface Swim { public abstract void swimming();}public class Demo07 { public static void main(String[] args) { // 应用匿名外部类 new Swim() { @Override public void swimming() { System.out.println("自由泳..."); } }.swimming(); // 接口 变量 = new 实现类(); // 多态,走子类的重写办法 Swim s2 = new Swim() { @Override public void swimming() { System.out.println("蛙泳..."); } }; s2.swimming(); s2.swimming(); }}3.9.5 匿名外部类的特点
- 定义一个没有名字的外部类
- 这个类实现了父类，或者父类接口
- 匿名外部类会创立这个没有名字的类的对象
3.9.6 匿名外部类的应用场景
通常在办法的形式参数是接口或者抽象类时，也能够将匿名外部类作为参数传递。代码如下：
interface Swim { public abstract void swimming();}public class Demo07 { public static void main(String[] args) { // 一般形式传入对象 // 创立实现类对象 Student s = new Student(); goSwimming(s); // 匿名外部类应用场景:作为办法参数传递 Swim s3 = new Swim() { @Override public void swimming() { System.out.println("蝶泳..."); } }; // 传入匿名外部类 goSwimming(s3); // 完满计划: 一步到位 goSwimming(new Swim() { public void swimming() { System.out.println("大学生, 蛙泳..."); } }); goSwimming(new Swim() { public void swimming() { System.out.println("小学生, 自由泳..."); } }); } // 定义一个办法,模仿请一些人去游泳 public static void goSwimming(Swim s) { s.swimming(); }}