目录
三、基本特征：封装、继承、多态 super、this关键字 抽象类 接口
一、面向对象与面向过程
现在越来越多的高级语言流行起来了，如大家耳熟能详的c++，python，java等，这些都是基于面向对象的语言，
而最最基础的，学校必学的语言----c语言它是属于面向过程的语言。
1、什么是面向过程？
面向过程：
就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
举例来说（办证）需要几步？
按照面向过程思想：
第一步：找到办事的人
第二步：给办事的准备资料
第三步 ：办完证，证件反馈给我
这里我们就看出来，面向过程就是把一件事按步骤一步一步来实现
代码表示
public void find(){}
public void handle(){}
public void feedback(){}
依次调用这些方法就行
2、什么是面向对象？
对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。
对象，就是对问题中的事物的抽象。
面向对象：
就是把现实中的事物都抽象为“对象”。每个对象是唯一的，且都可以拥有它的属性与行为。我们就可以通过调用这些对象的方法、属性去解决问题。
用面向对象思想解决大象装进冰箱
大致的了解到了对象这个概念，可以说是对现实事物的一种抽象映射。
例如在这个事件中：
冰箱作为一个对象；
大象作为一个对象。
冰箱有这些功能：开门、装物体、关门
class fridge{
public void open(大象){} //开门
public void putIn(大象){} //放进冰箱
public void close(大象){} //关门
}
class elephant{
public void eat(){} //吃
}
每个对象是独立的，有属于它自己的功能，只需要实现自己的功能就好。所以在建立对象的时候，只关注对象有什么的功能，先不考虑如何实现这些功能。
面向对象的好处，就包括有很好的延展性，比如我给大象赋予了一个吃的功能，它通过调用就可以在冰箱里去吃东西。面向对象就是把现实问题抽象为对象，通过调用每个对象的属性或功能去解决问题。
如果我要修改我的需求，把大象换成小狗，我用面向过程是不是得把每个步骤中的大象改为小狗。而用面向对象解决，我甚至可以重新创一个小狗对象，仅仅在调用的时候选择小狗就行了。
二、类的定义
1.类的概念：
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
2.对象的概念:
Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。
对象有以下特点：
1.对象具有属性和行为。
2.对象具有变化的状态。
3.对象具有唯一性。
4.对象都是某个类别的实例。
5.一切皆为对象，真实世界中的所有事物都可以视为对象。
类是对象的抽象，对象是类的具体。
3.事物与类的对比
现实世界的一类事物:
属性: 事物的状态信息。 行为: 事物能够做什么。
java中用class描述事物也是如此:
成员变量: 对应事物的属性。 成员方法: 对应事物的行为。
4.类的定义格式
public class ClassName{
//成员变量
//成员方法
}
定义类:就是定义类的成员，包括成员变量和成员方法。
成员变量:和以前定义变量几乎是一样的。只不过位置发生了改变，在类中，方法外。
成员方法:和以前定义方法几乎是一样的。只不过把static去掉。
类的定义格式举例:
public class Student{
//成员变量
String name; //姓名
int age; //年龄
}
三、基本特征：封装、继承、多态 super、this关键字 抽象类 接口
1、封装
（一）基本概念
将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。
意义：
1.将属性和方法放到一起做为一个整体，然后通过实例化对象来处理；
2.隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了；
3.对类的属性和方法增加 访问权限控制。
（二）四种访问控制级别
public：对外公开，访问级别最高
protected：只对同一个包中的类或者子类公开
默认：只对同一个包中的类公开
private：不对外公开，只能在对象内部访问，访问级别最低
（三）封装使用
把尽可能多的东西藏起来，对外提高简洁的接口
加入某种属性允许外界访问，那么提供访问该属性的公开方法。假如狗类有一个名字、年龄属性，不允许外界直接访问属性，但允许提供get和set方法来访问。
public 方法是公有的，可以直接访问
public class Student {
//成员变量 （属性）-----变量----储存数据的
public String name;
public String sex;
public int age;
public double height;public class Test {
public static void main(String[] args) {
Student student = new Student();
student.name = "胡图图";
student.sex = "男";
student.age = 6;
student.height = 1.11;
student.introduce();
}
}运行结果如下：
使用private方法，不能直接被外部访问，需要getter、setter方法
**
* 封装 :把属性私有化，实现了对外界的隐藏，然后通过共有的getter和setter方法对属性进行获取和赋值，保证了操作的安全性。
* 一般属性私有化(private)，方法公有化(public)，除非方法只是用来内部调用，可以private修饰
* 1.对属性使用private私有化进行修饰，实现了对外界的隐藏，外界不能够直接操作类的属性。
* 2.定义针对属性的getter和setter方法，完成对属性的获放和设置值，在发放中可以完成完会验证。
*
* 注意:
* 属性私有化后也可以通过有参数的构造方法进行赋值，且在有参构造方法中进行安全验证。
*/
public class Student {
//成员变量 （属性）-----变量----储存数据的
private String name;
private String sex;
private int age;
private double height;
/**
* 构造方法：用来初始化对象（构造方法是用来创建对象的）
* 语法： 访问修饰符 类名（参数列表..）{}
*/
//无参构造方法
public Student(){
System.out.println("无参的构造方法被调用！");
}
//有参构造方法:可以实现对类的属性进行赋值
public Student(String name, String sex, int age, double height) {
System.out.println("有参的构造方法被调用！");
this.name = name;
this.sex = sex;
if(age>=0&&age<=100){
this.age = age;
}
if (height>0){
this.height = height;
}
}
//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) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
//toString：打印类的对象是打印的内存地址，重写了该方法，打印时就显示的是类的属性值列表
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", height=" + height +
'}';
}
//成员方法（行为）----方法----完成---完成一些功能的---面向对象的体现
public void introduce(){
System.out.println("我是"+name+",性别"+sex+",今年"+age+"岁,身高:"+height);
}
}
public class Test {
public static void main(String[] args){
//调用构造方法，实例化类的对象
Student stu = new Student();
stu.setName("张三");
stu.setSex("男");
stu.setAge(18);
stu.setHeight(185.3);
stu.introduce();
System.out.println(stu);
System.out.println("----------------------");
Student stu1 = new Student("李四","男",29,217);
stu1.introduce();
}
} 
2、继承
让某个类型的对象获得另一个类型的对象的属性和方法。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
把几个类中相同的属性和方法抽离出来定义在基类中，子类不在定义这些属性和方法，继承之后，就相当于拥有了这些属性和方法。
1.子类继承父类，父类定义的公共的属性和方法子类会拥有，但是父类定义的私有化的属性和方法，子类不能继承。
2.父类继承过来方法，子类可以进行改造，重新实现功能(方法的重写)，调用的时候执行的是子类新实现的方法。
好处：
1、提高代码的复用性
2、类与类之间产生了关系，是多态的前提
通过extends关键字，可以声明一个子类继承另一个父类
定义格式如下：
class 子类 extends 父类{}
2.1 继承父类成员变量/方法
hanqishi继承了父类Dog
class Dog{
public String name="小白";
public void say(){
System.out.println("汪汪汪");
}
}
//哈奇士
class haqishi extends Dog {
public void test(){
System.out.println(name);
say();
}调用haqishi的test()方法，测试如下：
小白
汪汪汪
测试结果：子类haqishi继承了父类的成员变量和成员方法
父类继承过来的方法，子类可以进行改造，重新实现功能（方法的重写），调用的时候执行的是子类新实现的方法。
2.2 写父类方法
子类haqishi重写父类Dog的say方法
class Dog{
public String name="小白";
public void say(){
System.out.println("汪汪汪");
}
}
//哈奇士
class haqishi extends Dog {
public void say() {
//super.say(); 继承父类原有方法
System.out.println("哈哈哈"); }
}调用子类say方法，测试如下：
哈哈哈
2.3 重载父类方法
重载方法必须满足以下条件：
1、方法名相同
2、方法的参数类型、个数、顺序至少有一项不同
3、方法的返回类型可以不同
4、方法的修饰符可以不相同
class Dog{
public String name="小白";
public void say(){
System.out.println("汪汪汪");
}
}
//哈奇士
class haqishi extends Dog {
//重载 改变参数
public void say(String name) {
System.out.println(name+"汪汪汪");
}
//重载 改变参数+返回值
public int say(int age) {
System.out.println("汪汪汪"+age);
return age;
}
分别调用:/
haqishi h = new haqishi();
h.say();
h.say(“哈奇士”);
h.say(6);
结果如下：
汪汪汪
哈奇士汪汪汪
汪汪汪6
注意事项：
1.子类方法覆盖父类方法，必须要保证权限大于等于父类权限
2.子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。
2.4 继承后的特点一一构造方法
2.4.1 继承的特点
1.Java只支持单继承，不支持多继承。
2.Java支持多层继承(继承体系)。
2.4.2 继承的构造方法
1.构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2.构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super()，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。
代码如下:
class Fu {
private int n;
Fu(){
System.out.println("Fu()";
}
}
3、super和this
父类空间优先于子类对象产生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。理解图解如下:
3.1 super和this的含义
super : 代表父类的存储空间标识(可以理解为父亲的引用)。
this: 代表当前对象的引用(谁调用就代表谁)。
3.2 super和this的用法
1.访问成员
this.成员变量 -------------- 本类的
super.成员变量 ----------- 父类的
this.成员方法名() --------- 本类的super.成员方法名() ------- 父类的
区别:
1.表示只给自己属性赋值，父类对象的属性值是默认值
2.表示父类属性有值，子类独有的属性有值，然后继承父类的属性也有值
整体代码如下：
//父类
public class Person {
String name;
int age;
//类：变量和功能方法 有参无参构造方法 setter和getter方法 toString()
public Person(){
System.out.println("父类：Person构造方法被执行");
}
public void dy(){
System.out.println("父类：dy方法被执行");
}
}
//子类
public class Student extends Person{
String stuNum;
public Student() {
//super()表示调用父类的构造方法， 不写系统其实默认在子类的构造方法中调用了父类的构造方法，并且只能在第一行写
super();
System.out.println("Student类的构造方法执行");
}
public void fun(){
this.stuNum = "1001";
this.name="zy";
this.age=19;
}
public void fun1(){
this.stuNum = "1001";
super.name="zy";
super.age=19;
}
public void fun2(){
super.name="xxx";
super.age=111;
}
public void fun3(){
System.out.println(super.name);
System.out.println(super.age);
}
public void dy(){
System.out.println("子类重写dy方法执行");
}
public void test(){
this.dy();
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", stuNum='" + stuNum + '\'' +
'}';
}
}
//测试类
public class Test01 {
public static void main(String[] args) {
Student student = new Student();//调用无参的构造方法，实例化类的对象 默认先实例化它的父类对象
System.out.println("------------------");
student.fun2();
student.fun(); //Student{name='zy', age=19, stuNum='1001'}
student.fun();
student.fun2(); //Student{name='xxx', age=111, stuNum='1001'}
student.fun3();
System.out.println(student);
Student s2 = new Student();
System.out.println("----------");
s2.test();
}
}
运行结果：
4、 抽象类
4.1 概述
由来：
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
定义：
抽象方法: 没有方法体的方法。
抽象类:包含抽象方法的类。
4.2 abstract使用格式
抽象方法
使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
/**
* 抽象类：使用abstract关键字进行修饰的类叫做抽象类
* 1.抽象类里面不是必须由抽象方法
* 2.一个类里面有抽象方法，这个类必须满足抽象类
*/
//父类
public abstract class Person {
String name;
int age;
/**
* 抽象方法：
* 1.方法只有声明没有方法体： 声明即规定方法三要素： 方法名、参数列表、返回值类型
* 2.要使用abstract关键字进行修饰
*
* 定义抽象方法的意义：
* 1.能够对子类进行约束：子类必须实现父类的抽象方法，或者子类声明为抽象类
* 2.抽象类通过定义抽象方法实现了一种规范，要求它的子类必须具备某种功能，具体如何实现以子类的具体实现为准
*/
public void study(){
}
}
//子类
public class Student extends Person{
String stuNo;
public void study(){
System.out.println("Student子类重写study方法执行");
}
}
//子类
public class Teacher extends Person{
String tid;
}
匿名内部类：
public class test1 {
public static void main(String[] args) {
//匿名内部类
Person p = new Person() {
@Override
public void study() {
//实现抽象方法
}
};
Student student = new Student();
}
}4.3 注意事项
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。
1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解: 子类的构造方法中，有默认的super()，需要访问父类构造方法。
3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
理解:未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
理解:假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
5、接口
5.1 概述
接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法 (DK 7及以前，默认方法和静态方法 (DK 8)，私有方法(DK 9)。
接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成cass文件，但一定要明确它并不是类，而是另外一种引用数据类型。
引用数据类型:数组，类，接口。
接口的使用，它不能创建对象，但是可以被实现 ( implements，类似于被继承)。一个实现接口的类(可以看做是接口的子类)，需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类.
5.2 定义格式
public interface 接口名称{
// 抽象方法
// 默认方法
// 静态方法
//私有方法}
含有抽象方法
抽象方法: 使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。
代码如下:
public interface InterFaceName {
public abstract void method();}
含有默认方法和静态方法
默认方法: 使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法: 使用 static 修饰，供接口直接调用。
代码如下:
public interface InterFaceName {
public default yoid method() {
//执行语句}
public static void method2() {
//执行语句}
}
含有私有方法和私有静态方法
私有方法: 使用 private 修饰，供接口中的默认方法或者静态方法调用
代码如下:
public interface InterFaceName {
private void method() {
//执语句}
}
5.3 基本的实现
实现的概述
类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。
非抽象子类实现接口:
1.必须重写接口中所有抽象方法。
2.继承了接口的默认方法，即可以直接调用，也可以重写。
实现格式:
class 类名 implements 接口名 {
//重写接口中抽象方法[必须]
//重写接口中默认方法[可选]}
静态方法的使用
静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用
私有方法的使用
私有方法:只有默认方法可以调用。
私有静态方法:默认方法和静态方法可以调用。
如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用，从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。同学们在已学技术的基础上，可以自行测试。
5.4 其他成员特点
接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。
整体代码如下：
/**
* 接口的定义使用interface关键字
* 1.接口不能有成员变量
* 2.接口中一般定义的是抽象方法，JDK8开始可以定义默认方法和静态方法，JDK9可以定义私有方法
* 3.通过定义接口，就相当于定义一种规范或者约束，实现该接口的子类必须重写接口中定义的抽象方法，或者子类定义为抽象类
*
* 在程序开发中，一般定义接口用来规定完成模块操作的各个处理方法，具体的功能实现根据不同的需求定义不同的实现类来完成功能
*/
//父类
public interface USB {
//只能定义方法。
//抽象方法
void read();
void write();
//默认方法-------JDK8 子类会被继承
public default void run(){
System.out.println("启动");
}
//静态方法-------JDK8 不会被继承，子类也无法调用
public static void fun(){
}
//私有方法-------JDK9 子类不会被继承
// private void fun1(){
//
// }
}
//子类
public class Kingston implements USB{
@Override
public void read() {
System.out.println("Kingston执行读操作");
}
@Override
public void write() {
System.out.println("Kingston执行写操作");
}
}
//子类
public class SanDisk implements USB{
@Override
public void read() {
System.out.println("SanDisk执行读操作");
}
@Override
public void write() {
System.out.println("SanDisk执行写操作");
}
}
6、多态
6.1概述
多态是继封装、继承之后，面向对象的第三大特性。
多态是出现在继承或者实现关系中的。
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。
定义
多态: 是指同一行为，具有多个不同表现形式。
前提[重点]
1.继承或者实现[二选一]
2. 方法的重写[意义体现: 不重写，无意义]
3.父类引用指向子类对象[格式体现]
6.2 多态的体现
多态体现的格式:
父类类型 变量名 = new 子类对象；
变量名.方法名();
父类类型: 指子类对象继承的父类类型，或者实现的父接口类型。
代码如下:
Fu f = new Zi();
f.method();
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误;如果有，执行的是子类重写后方法。
6.3 多态的利弊
我们已经知道多态编译阶段是看左边父类类型的，如果子类有些独有的功能，此时多态的写法就无法访问子类独有功能了
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。
6.4 引用类型转换
6.4.1 为什么要转型
多态的写法就无法访问子类独有功能了。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
多态的转型分为向上转型与向下转型两种：
向上转型(自动转换)
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。
使用格式:
父类类型 变量名 = new 子类类型();
如: Animal a = new cat();
原因是：父类类型相对与子类来说是大范围的类型，Animal是动物类，是父类类型。Cat是猫类，是子类类型。Animal类型的范围当然很大，包含一切动物。所以子类范围小可以直接自动转型给父类类型的变量。
向下转型(强制转换)
向下转型:父类类型向子类类型向下转换的过程，这个过程是强制的。 一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
子类类刑 变量名 =(子类类型) 父类变量名;
如: Animal a = new cat();Cat c =(Cat) a;
整体代码：
/**
* 多态：是指同一行为，具有多个不同表现形式。（调用同样的方法，执行的是不同的功能）
* 1. 发生在有继承或者实现接口的情况下
* 2. 在子类中对方法进行了重写
* 3.父类引用指向子类对象 父类类型 变量名=new 子类对象()
*
* 多态的好处： 在开发中可以把父类（接口类型）类型定义为方法的形参，在实际调用的时候传入的实际参数就比较灵活了，
* 可以传入父类类型的对象，也可以传入任意一个子类类型的对象。
*
* 多态本质就是子类对象向上转型为父类的引用（子类对象赋值给父类变量），;
*/
//测试类
public class Test02 {
public static void main(String[] args) {
// Animal a1 = new Cat();
// Animal a2 = new Dog();
// a1.call();
// a2.call();
System.out.println("---------------------------");
//调用类里面的方法:静态方法--直接类名.方法名; 非静态方法--实例化对象，然后对象名.方法名;
// AnimalAction ac = new AnimalAction();
// //如果没有父类变量 = 子类对象的这种技术存在
// //多态在方法调用中的应用体现
// Animal a1 = new Animal();
// Animal a2 = new Cat();
// Animal a3 = new Dog();
// ac.action(a1);
Cat c1 = new Cat();
Animal a= new Cat();
a.call();
Cat c = (Cat) new Animal();
c.sleep();
}
}
//子类
public class Cat extends Animal{
public void call(){
System.out.println("喵喵叫");
}
public void sleep(){
System.out.println("猫在睡觉...");
}
}
//子类
public class Dog extends Animal{
public void call(){
System.out.println("汪汪叫");
}
}
//父类
public class Animal {
public void call(){
System.out.println("动物在叫");
}
}
public class AnimalAction {
/**
* 给方法一个Animal类型的对象（变量），然后调用call()方法
* @param animal
*/
public void action(Animal animal){
animal.call();
}
}