### 问题
~~~
public class DianWorker {
String name;
String sex;
public void work() {
System.out.println(name+"做着电工的工作");
}
}
~~~
~~~
public class QianWorker {
String name;
String sex;
public void work() {
System.out.println(name+"做着钳工的工作");
}
}
~~~
~~~
public class WaWorker {
String name;
String sex;
public void work() {
System.out.println(name+"做着瓦工的工作");
}
}
~~~
三个类当中存在着相同的属性和行为，这里写了三次，为了解决这个问题--**继承**
***
### 继承(泛化)（extends）
#### 概念
一个Java类可以从一个现有的类（父类，基类，超类）当中派生出来，派生出来的类（子类）具有父类的所有属性和方法，除了**构造器**和**私有成员**
#### 特点
子类还可以增加自己独有的属性和方法来拓展功能
Java中的继承--单继承（一个类只能有一个直接父类）
继承提高了代码的复用性，也是实现**开闭原则**的基础
**开闭原则：对拓展开放，对修改关闭**
#### 如何判断继承关系
1.A is a kind of B（A是一种B）-->B就是A的父类
2.**里氏替换原则**--任何父类可以出现的地方，子类一定可以出现，子类能够完全替代父类的功能
### 子类实例化过程
实例化子类对象，子类构造器先默认去调用父类的无参构造器先生成父类对象，然后再生成子类对象,如果父类没有无参构造器，子类构造器就必须显式调用父类的其他有参构造器
### super关键字
代表父类对象，使用与this完全一样
1.super.属性，super.方法名()
2.super()父类构造器
***
### 封装
#### 访问权限操作符
#### 概念
将属性和方法用不同的访问权限操作符修饰（控制可见范围），放入一个类中的过程
### 方法重写（override覆盖，rewrite，运行时多态）
一定发生在子类当中，与父类**同名，同参，同返回值类型**的方法，子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限
#### 重写（运行时多态，override）与重载（编译时多态,overload）的区别？
~~~
// 重写一定发生在子类当中，与父类方法同名，同参，同返回值类型的方法，子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限
// 重载：同一个类当中，同名不同参的方法，与返回值类型无关
~~~
### 多态（解耦合）
字面意义：一个事物的不同形态（对同一消息做出的不同响应）
编码意义：一个方法的不同实现
设计意义：将做什么和怎么做分开
前提：
1.要有泛化（继承）关系
2.要有方法重写
3.要有上溯造型（父类引用指向子类对象）
***
### static静态
static能修饰方法，属性。
static修饰的方法（静态方法）和属性（静态属性），可以直接通过类名调用，所以静态属性和静态方法不在堆区当中，而在方法区当中的静态区（共享区）
静态区中的静态属性和静态方法归这个类所有对象共享
静态方法只能直接访问静态成员
#### 备注：
1.static不能修饰类
2.static不能修饰构造器
3.static不能修饰局部变量
4.static不能修饰抽象方法
### 静态块 : 给静态属性初始化
执行时机：类型信息被加载到方法区中时
~~~
static {
System.out.println("静态块被调用");
num = 100;
}
~~~
***
### 单例模式（保证一个类只有一个实例-->对象）
~~~
public class Singleton {
// 饿汉模式--饿加载
private static Singleton s = new Singleton();
/*
* 单例模式：
* 保证一个类只有一个实例（对象）
*/
// 构造器私有--不让其他类随意new对象
private Singleton() {
}
// 返回一个实例的方法--公有，静态的，返回值类型为Singleton的方法
public static Singleton getInstance() {
return s;
}
}
~~~
**懒加载**
~~~
public class Singleton {
// 懒汉模式--懒加载
private static Singleton s;
/*
* 单例模式：
* 保证一个类只有一个实例（对象）
*/
// 构造器私有--不让其他类随意new对象
private Singleton() {
}
// 返回一个实例的方法--公有，静态的，返回值类型为Singleton的方法
public static Singleton getInstance() {
if(s == null){
s = new Singleton();
}
return s;
}
}
~~~
***
### final关键字
final能修饰类，方法，属性
final修饰类，最后的类，不能被继承
final修饰方法，最后的方法，不能被重写
final修饰属性，最后的属性，不能被修改
***
### 抽象类（abstract）
抽象方法：没有方法体（块），如果一个类当中存在抽象方法，那么这个类必须是抽象类
**抽象类不能实例化**（但是有构造器），它唯一的作用-->被继承（充当父类）
一旦一个子类继承了一个抽象类，就必须重写父类的所有抽象方法，除非这个子类也是抽象类
#### 思考：abstract与final能不能同时修饰一个类？
不能，abstract类唯一的作用就是被继承；final类不能被继承，即使能修饰，这个类也毫无意义
***
### 接口（interface）
如果一个类当中的所有方法都是抽象方法，这个类可以定义为一个接口--接口不是类
接口只能用**public**和默认修饰，**工作不存在默认接口**
因为Java类是单继承，所以出现了接口，为的是弥补单继承的缺点
接口不能实例化（没有构造器），一个类实现了一个接口，必须实现它所有方法，除非这个类是抽象类
#### 接口中的成员
1.只允许声明常量
2.只允许声明抽象方法
属性，存在默认前缀**public static final**
方法，存在默认前缀**public abstract**
**类与类的关系--单继承**
**类与接口的关系--多实现**
~~~
public class InterfaceAImp implements InterfaceA{
public void test() {
System.out.println("实现A接口");
}
}
~~~
**接口与接口的关系--多继承**
~~~
public interface InterB extends InterA,InterC{
}
~~~
***
#### 面试题：抽象类和接口有哪些区别?
1.抽象类和接口都不能实例化
2.抽象类有构造器，接口没有
3.类是单继承，接口是多实现
4.抽象类是抽象成员和非抽象成员的集合体，接口中只允许存在常量和抽象方法
***
### 接口的应用
接口就是一套规范
~~~
public interface News {
// 增加一条新闻
void addNews();
}
~~~
~~~
public class Sports implements News{
public void addNews() {
System.out.println("发布一条体育新闻到体育模块");
}
}
~~~
~~~
public class Happy implements News{
public void addNews() {
System.out.println("发布一条娱乐新闻到娱乐模块");
}
}
~~~
~~~
public class ZhengZhi implements News{
public void addNews() {
System.out.println("发布一条政治新闻到政治模块");
}
}
~~~
~~~
public class Main {
public static void main(String[] args) {
News n = null;
while(true) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入要发布什么新闻：");
System.out.println("1--------体育新闻;");
System.out.println("2--------娱乐新闻;");
System.out.println("3--------政治新闻;");
System.out.println("4--------退出程序;");
int option = scan.nextInt();
if(option < 0 || option > 4) {
System.out.println("无效数字");
continue;
}
switch(option) {
case 1:
n = new Sports();
break;
case 2:
n = new Happy();
break;
case 3:
n = new ZhengZhi();
break;
case 4:
System.out.println("谢谢！！！！");
return;
}
n.addNews();
}
}
}
~~~
***
### 内部类（innerClass）
内部类的唯一作用：能够直接访问外部类成员，包括私有
解决接口中方法同名同参问题：
~~~
public class InterImpTest implements Interface1{
public void test() {
System.out.println("1");
}
public class InnerClass implements Interface2{
public int test() {
System.out.println("2");
return 0;
}
}
}
~~~
***
#### 总结：
**1.面向对象的四大特性**
①继承
一个Java类可以从一个现有的类（父类，基类，超类）当中派生出来，派生出来的类（子类）具有父类的所有属性和方法，除了**构造器**和**私有成员**，子类还可以增加自己独有的属性和方法来拓展功能
②封装
将属性和方法用不同的访问权限操作符修饰（控制可见范围），放入一个类中的过程
③多态（解耦合）
对同一消息做出的不同响应
前提：
1.要有泛化（继承）关系
2.要有方法重写
3.要有上溯造型（父类引用指向子类对象）
④抽象
将事物的主要特征和行为抽象成概念模型，在Java中抽象类和接口都是抽象的体现
***
**2.static**
static能修饰方法，属性。
static修饰的方法（静态方法）和属性（静态属性），可以直接通过类名调用，所以静态属性和静态方法不在堆区当中，而在方法区当中的静态区（共享区）
静态区中的静态属性和静态方法归这个类所有对象共享
静态方法只能直接访问静态成员
#### 备注：
static不能修饰类
static不能修饰构造器
static不能修饰局部变量
static不能修饰抽象方法
***
**3.单例模式**
懒加载
***
**4.抽象类和接口**
抽象类和接口都不能实例化
抽象类有构造器，接口没有
类是单继承，接口是多实现
抽象类是抽象成员和非抽象成员的集合体，接口中只允许存在常量和抽象方法
***
**5.final关键字**
final能修饰类，方法，属性
final修饰类，最后的类，不能被继承
final修饰方法，最后的方法，不能被重写
final修饰属性，最后的属性，不能被修改
***
**6.方法的重写**
一定发生在子类当中，与父类**同名，同参，同返回值类型**的方法，子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限
***
**7.上塑造型**
父类引用指向子类对象
