面向对象 三大特征 封装 继承 多态 （完整版）

# 面向对象大总结 

## 第一章  基本内容--封装

### 1.1 如何定义一个类

~~~java
public class 类名{
    //成员变量
    //成员方法
}
注意类名要符合 第一个字母大写后面每个单词首字母大写。
 特征 定义为成员变量
 功能 定义为成员方法
public class Dog{
   String name;
   int age;
   public void load(){
      System.out.println("汪汪汪")
   }
}
~~~

### 1.2 使用类 --创建对象

~~~java
类名 对象名 = new 类名();  
//           等号右边的叫对象 ,因为是new才产生了对象的空间
// 等号左边的叫引用变量, 它是用来指向右边的空间的.
Dog dog = new Dog();
使用成员
对象名.属性名  对象名.方法名()
dog.name = "大黄";
dog.load();
~~~

### 1.3 封装概念 

~~~java
什么是封装呢？
   隐藏实现细节，提供公共的访问方式。
怎么去隐藏实现细节
  private 私有的，隐藏成员变量。
            外界无法直接访问,只能在本类中访问    --- 合理隐藏.
  需要提供 set/get 公共访问方式。
          set 设置的意思
          get 获取的意思
                                                合理暴露.
~~~

### 1.4 构造方法 

~~~java
构造方法的作用:
   初始化对象用的，主要是初始化成员变量。
构造什么被调用:
   new 的时候. new Student(); new Student("小南",20);
构造方法特点:
   a:方法名和类名一样
   b:没有返回值，连void都没有。
构造方法注意事项:
   a:所有类都有构造，默认的构造是空参。
   b:我们写了构造，那么默认的就没有了。
   c:开发建议 写空参、满参。
~~~

~~~java
标准的类---JavaBean
public class Dog{
   private String name;
   private int age;
   
   public Dog(){}
   
   public Dog(String name,int age){
      this.name = name;
      this.age = age;
   }
   public void setName(String name){
      this.name=name;
   }
   public void setAge(int age){
       this.age=age;
   }
   public String getName(){
      return name;
   }
   public int getAge(){
      return age;
   }
   
   public void load(){
      System.out.println("汪汪汪")
   }
}
~~~

### 1.5 this关键字 

~~~java
this代表当前对象的引用。
   作用 区分成员变量和局部变量。
   this只能存在于非静态方法中。谁调用这个方法this就是谁。
面试题:
   在一个静态方法中 能不能有this关键字 不能。
   
~~~

## 第二章 继承

### 2.1 继承基本概念 

~~~java
什么是继承:
  概念: 让类和类之间产生关系(子父关系),子类自动拥有父类中定义的属性和方法.
继承的格式:
   class 子类名 extends 父类名{}
举个例子:
   class Cat extends Animal{}
~~~

### 2.2 继承中成员访问特点

~~~java
遵循就近原则
    方法中变量的访问特点
       先从局部位置找--当前类的成员位置找--父类的成员位置...实在找不到就报错
   方法调用的特点
       先从本类中查看有没有这个方法,有就调用.
        没有再去父类中找.
   其中
    如果我们想要 访问本类中的成员 就使用 this关键字.
    如果我们想要 访问父类中的成员 就使用 super关键字.
~~~

~~~java
需要记住
  子类的构造的第一行默认是 super().
    代表着子类对象产生的时候,会先调用父类的构造,完成父类成员初始化.
    以保障子类可以用到父类中的属性.
~~~

### 2.3 方法的重写 

~~~java
概念
  在子类中出现了与父类方法声明一模一样的方法.(方法声明 返回值类型 方法名 参数列表)
    这种现象称为方法的覆盖,也叫重写.
重写的作用:
   在原有功能的基础上可以做升级.
注意事项
   私有的不存在重写.静态也不存在重写.
   子类重写的方法 访问权限要大于父类的方法,发扬光大.    
~~~

### 2.4 权限大小关系

~~~java
public > protected      >    默认   > private
公共的    本包及其他包子类     本包中      本类
~~~

### 2.5 抽象  

~~~java
关键字: 
   abstract
可以修饰什么?
   修饰类 --- 抽象类
      格式 
         public abstract class 类名{}
      特点:
         里面可以有抽象方法,也可以有非抽象方法.
         不能直接创建对象,因为里面有抽象方法.    
 修饰方法--抽象方法
      格式
        public abstract 返回类型 方法名(参数列表);
      特点
         没有方法体的实现,仅仅是方法的定义.
          
 抽象类没法直接创建对象,所以一般来说抽象类是作为父类出现的,
需要子类去继承,重写抽象方法.
   抽象类中的构造有什么用? 方便子类进行父类成员初始化的. 
~~~

### 2.6 接口 

~~~java
接口的定义:
    用于定义规范的叫接口.
    接口呢就是一些功能(方法)的集合,只定义抽象方法,没有给具体实现.  
定义关键字 
   interface
   public interface 接口名{}
接口既然是方法的集合，那么这些方法必然要被实现，被谁实现。
      由具体的子类来实现
      实现格式:
      class 具体类 implements 接口名{}
     一旦这个类实现了接口,那么所有的抽象方法都要重写.
接口里面有什么？
     成员变量---被 public static final 修饰的
                    静态的常量,通过接口名直接调用.
     成员方法 -- 被public abstract 
          JDK7及以前 只能有抽象方法
          JDK8可以有 默认方法和静态方法
          JDK9可以有 私有方法
~~~

### 接口和接口 类和类 类和接口 之间都有什么关系？

~~~java
类与类 继承关系 支持单继承 不支持多继承 支持多层继承
类与接口 实现关系 可以单实现 可以多实现
接口与接口 是继承关系 可以单继承 可以多继承 
~~~

## 第三章 多态 

### 3.1 多态的概念 

~~~java
自然界中  一种事物的多种形态
java中   一个对象,另外形态
   Lv lv = new Lv(); 本态
   Animal a = new Lv();//多态

~~~

### 3.2 多态的前提

~~~java
一般有继承或者实现
一般会进行方法的重写
父类引用指向子类对象
~~~

### 3.3 多态的转型 

~~~java
向上转型
   父类类型 fu =  new 子类对象();
向下转型
  子类类型 zi = (子类类型)fu;
 
~~~

### 3.4 多态成员访问特点

~~~java
口诀:
   编译看左边,检查语法错误
   运行成员变量看左边  表象
      成员方法看右边  实际的对象
~~~

### 3.5 多态的好处 

~~~java
提高了扩展性和灵活性。
feedAnimal(Animal a)//传递都是地址值。
~~~

## 第四章  其他知识点 

### 4.1 final关键字 

~~~java
含义:最终的,形容词.
    修饰符 
修饰的类:
     最终类,不能被继承.
修饰的方法:
     最终方法,不能被重写.
修饰的变量:
     最终变量--常量,只能赋值一次.不能进行二次赋值.
注意:
    修饰的变量是基本类型,数值不能再发生改变.
    修饰的变量是引用类型,地址值不能再发生改变.   
        
学它的主要目的
   1:了解基本知识点.
   2:查看源码.
   3:将来看同事写的代码.
   4:在开发时候使用,主要用于修饰变量.定义常量    
  
~~~

### 4.2 static关键字 

~~~java
含义:
   静态的 与类相关的
可以修饰什么:
   可以修饰类中的成员
      比如
        修饰成员变量--静态成员变量
        修饰成员方法--静态成员方法
        修饰代码块  --静态代码块
        
被静态修饰的有什么特点
        静态变量会随着类的加载而加载.
        静态代码块会随着类的加载而执行.
        且只加载一次,因为类加载一次.
        静态内容优先于对象存在.
使用上特点
   建议直接使用类名调用.
   静态中只能访问静态内容.
       
学习静态关键字的目的
  1:为了能够使用后期学习的API.
  2:将来创建的工具类都是静态的.
  3:将来学习一些设计模式的时候还要用.
  4:看源码用.    
       
~~~

### 4.3 abstract 不能和 final  static 一块使用 

​    因为没有意义.有矛盾.

### 4.4 内部类 

~~~java
含义:
   在一个类中定义了另外一个类.
       类A中定义了类B 那么类B 叫 类A 的内部类.
按照位置分
   成员内部类
   局部内部类
访问特点
   内部类可以访问到外部类的成员.
   想要访问 成员内部类 需要先找到外部类对象,才能找到内部类对象.
需要注意的是 内部类 也会生成.class文件.
       
学习内部类的目的
  1:为了源码
  2:为了能够理解匿名内部类的命名.
~~~

### 4.5 匿名内部类 

~~~java
本质:
   简单说就是一个子类对象.
   详细说 就是 一个快速构建  接口或者类的子类对象.
为什么叫匿名内部类呢?
    因为产生了一个内部类,但是没名字,所以叫匿名内部类.
格式:
    new 接口/类名(){
        
        重写方法
    };
学它的目的
  1:可以在不构建类的情况下产生一个子类对象.
  2:看源码
  3:在以后 创建多线程的时候可以玩一玩, 可以使用lambda优化.

       
~~~