2.面向对象三大特征

1. 知识回顾
   1. 学习上章面向对象思想,算是迈进面向对象编程的一道必过门坎了
   2. 面向对象如此新奇的思想必有它特别的地方
2. 新概念-类
   1. 什么是类
      1. 类是对现实生活中一类具有共同特征的事物的抽象
         1) 可包含属性(特征)
         2) 可包含方法(行为)
      2. 类是面向对象程序中最基本的程序单元
      3. 实质上定义的是一种数据类型(对象类型)
   2. 类的作用
      1. 生活中:更好的描述客观事务,表达含义(把书放在桌子上[不论是什么书都要放在在桌子上])
      2. 程序中:创建需要的对象
   3. 如何使用类
      1. 定义语法
         访问修饰符 class 类名{
         可有属性的定义;
         可有方法的定义;
         }
      2. 说明
         1) 类中定义的属性称为成员属性
         1. 定义语法:访问修饰符 数据类型 成员变量名 [= 初始值];
         2) 类中定义的方法称为成员方法
         1. 定义语法:访问修饰符 返回值类型 方法名(参数){}
         3) 一个类根据需要定义成员属性或成员方法
         4) 类中隐藏的构造方法(默认构造方法)
         1. 内容
         public 类名(){}
         2. 说明
         1. 构造方法的名字和类名相同，并且没有返回值
         2. Java的类都要求有构造方法，如果没有定义构造方法，Java编译器会为我们提供一个缺省的构造方法，也就是不带参数的构造方法
         3. 构造方法是用来创建对象的
         4. 如何重载构造方法
         public 类名(){参数}
         5. 如果需要重载构造方法,建议添加上默认的构造方法,因为如果需要调用默认时,程序就不会报找不到该构造方法了
3. 新概念-对象
   1. 什么是对象
      1. 能具体感知的事物
      2. 软件的对象概念是由现实世界对象抽象而来
   2. 对象的作用
      1. 生活中:真实的描述客观存在的事务
      2. 程序中:存储数据或组织功能代码(不再是写函数了,而是找对象,用对象)
         1) 属性:现实世界对象的状态保存在软件对象的变量中
         2) 方法:现实世界对象的行为通过软件对象的方法（函数）来实现
         1. [访问修饰符] [其它修饰符] 返回值类型 方法名([参数]){}
   3. 如何使用对象
      1. 创建语法
         类型 对象名 = new 类型([参数]);
      2. 说明
         1) new关键字起到调用构造函数的作用,可根据需要传入参数
         2) 对象是引用变量,同前面基本数据类型定义的变量不同这处是:它有属性与方法
         3) 如何区分值变量与引用变量
         1. 使用工具能.出提示的变量即引用变量
4. 类和对象的关系
   1. 类是对象的抽象,对象是类的实例(类是创建对象的模板，对象是类的实例)
5. 其它常识
   1. 成员变量与局部变量的区别
      1. 定义位置不同:前者在类中后者在方法中
      2. 内存位置不同:前者在堆内存后者在栈内存
      3. 初始情况不同:前者默认会初始化后者不会
         数值型默认值是0;boolean默认值是false;char是'\0'[一个字节的空白];对象是null
      4. 如果成员变量与局部变量名称一致:采用就近原则
   2. 静态变量与成员变量的区别
      1. 所属不同:前者归类所属,也称为类变量;后者归对象所属,也称为实例变量
      2. 内存位置不同:前者在方法区的静态区,后者在在堆内存
      3. 出现时间不同:前者随与类同生同灭;后者与对象同灭
      4. 调用方式不同:前者可通过类调用也可通过对象调用;后者只能通过对象调用
   3. 程序入口方法理解
      1. 固定格式:public static void main(String args[]){}
      2. 说明
         1) public:总能被JVM调用
         2) static:能快速的被找到
         3) void:不需要返回值
         4) String args[]:可提供字符串参数(1.不要使用java HelloWorld.class;2.传入参数不要用,号使用空格)
   4. 方法的重载
      1. 在同一个类中,方法名相同,参数列表不同(参数个数,参数的类型)
      2. 与有无返回值及返回值的类型无关
   5. 方法的重写
      1. 发生在子类中
      2. 子类重写父类的方法:基本相同,目的是重写内容
         1) 访问权限不能更低(最好相同)
   6. 传值与传引用
      1. 基本数据类型作参数时:传递的是实际的值(两分相同的数据)
      2. 引用数据类型作参数时:传递的是地址(同一份数据)

   7. 访问修饰符(决定类,类成员能否被访问)
      修饰符关键字 同类中 同包中 子类中 其它包中 说明
      public √ √ √ √ 完全访问,不受限制
      protected √ √ √ × 继承的类可访问
      default(缺省) √ √ × × 同一包中,可相互访问
      private √ × × × 本类中才可访问

   8. 其它修饰符
      1. static
         1. 它是什么
            静态修饰符

         2. 它的作用
            可修饰类成员
            修饰的成员变量称为静态变量
            修饰的成员方法称为静态方法
            修饰的内容归类所属,不归方法所属
            可直接通过类名引用,不必用实例化对象引用
            静态的方法不能访问非静态的方法或属性,反之则可以
            标记静态代码块
            类加载时就被调用,先于main方法
            只会执行一次,常用于程序的初始化工作

         3. 如何使用
            可修饰类成员,放在访问修饰符后类成员前:[访问修饰符] [其它修饰符] 类成员
            修饰代码块,放置在大括号这前:static{}
      2. final
         1. 它是什么
            最终修饰符
         2. 它的作用
            可修饰类
            修饰的类不能被继承,即不会有子类
            可修饰类成员
            修饰成员变量:与public static + final来定义一个常量[通常是static final这种写法]
            修饰成员方法:修饰的方法不能被重写

         3. 如何使用
            修饰类:放置在class前即可

            修饰类成员
            成员变量:放置在变量名前即可:

              成员方法:放置在返回值类型前即可

      3. abstract
         1. 它是什么
            1. 抽象修饰符
         2. 它的作用
            1. 可修饰类
               1. 修饰的类称为抽象类:抽象类不能被实例化,其它特征与类相同
            2. 可修饰方法
               1. 修饰的方法称为抽象方法:只有方法声明而没有方法体
               2. 抽象方法没有方法体,必须被子类重写后才能使用
         3. 如何使用
            1. 修饰类:放置在class前即可
            2. 修饰方法:放置在返回值类型前即可
            3. 拥有抽象方法的类必定是抽象类,反之则不然
            4. abstract与final作用是相反的,故它们不能同时用于修饰类或成员方法
            5. abstract不能与static同用(static修饰的内容归类所属)
            6. abstract不能与private同用(pricate修饰的内容,子类无法继承,不能重写)
   9. 总结访问修饰符与其它修饰符
      1. 前后顺序没要求,但是通常是下面几种写法
         public static final 数据类型 成员变量名
         public static final 返回值类型 方法名(){}
         public static 返回值类型 方法名(){}
         public 返回值类型 方法名(){}
         public abstract 类名{}
         public abstract 返回值类型 方法名();
      2. 构造方法不能被继承,不能被static,final,abstract修饰
         可以使用访问修饰符修饰(单例模式就使用了此招)
   10. 代码块
       1. 它是什么
          使用{}括起来的代码即为代码块
          分类
          局部代码块:在方法中定义
          构造代码块:在类中,方法外定义
          静态代码块:在类中,方法外且加上static定义
       2. 它的作用
          局部代码块:限定变量生命周期,极早释放,提高内存使用效率
          构造代码块:先用构造方法前调用:可把相同的代码放于此,方便多个构造方法共享(无论你是有参还是无参)
          静态代码块:给类初始化,只执行一次
       3. 如何使用
          根据它的作用,选择适当的代码块,定义好了即使用好了
          执行顺序:静态代码块>构造代码块>构造函数
6. 封装特征
   1. 什么是封装
      1. 对外隐藏细节,但提供外部使用的接口
   2. 封装的好处
      1. 安全(能控制外部的恶意数据)
   3. 如何使用封装
      1. 把类中成员属性私有化(使用private访问修饰符)
      2. 提供公开的(public访问修饰符)set属性名()及get属性名()方法(获取数据,改变数据的方法)
         1)
   4. 说明
      1. 如果属性较多时,可使用快捷键:alt+shift+s
         1)
      2. 当然,属性名同变量名,要遵守命名规则(我上面取名不符合规范)
      3. this知识点
         1) 它是什么:它表示当前对象的引用(由实际对象决定它具体的值)
         2) 它的作用
         1. 所在类的对象引用(对象本身)
         1. 每当调用一个实例方法时，this变量将被设置成引用该实例方法的特定的类对象。方法的代码接着会与this所代表的对象的特定数据建立关联。
         2. 可以明确区分访问的是成员变量还是局部变量(即使它们名称相同):this.a = a;
         1. 当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。
         3) 如何用它
         1. 当成对象用即可
         2. 不能用在静态的内容中
7. 继承特征
   1. 什么是继承
      1. 从已有的类中派生出新的类(原类叫父类(超类,基类),新类叫子类
      2. 新的类能够吸收已有类的数据属性和行为
   2. 继承的作用
      1. 提高代码的重用(减少冗余)
      2. 子类可以扩展新的能力(多态的基础)
   3. 如何使用继承

      1. 使用语法
         1) 创建父类,使用创建类的语法即可

         2) 创建子类,使用创建类的语法,在类名后添加extends 父类名称
         1.
         2.

      2. 说明
         1) 一个父类可以有任意个子类
         2) Object要么是一个类的父类,要么是一个类的祖宗:因为定义一个类时:默认有extends Object
         3) java只支持单继承:没有extends A,B这种情况;但是有A>B>C,即支持多层继承
         4) 子类构造方法(不管有参,无参)默认会调用父类无参构造方法
         1.
         5) 子类构造方法如果想调用父类有参构造方法,可用super(参数)来指定
         1.
         6) 子类不能继承父类的内容
         1. 构造方法
         2. 私有成员
         7) 只有有is->a的关系就可以使用继承来设计程序中的类
         8) super与this的异同
         1. 异
         1. 前者代表父类对象,用于访问父类成员,调用父类的构造方法
         2. 后者代表所在类对象的引用,用于访问本类的成员,调用本类的其它构造方法
         2. 同
         1. 在构造函数中调用构造方法
         1. this([参数]):
         2. super([参数])
         3. 有参数调用的是有参构造函数
         4. 无论是this([参数]),还是this([参数]),只能放在第一句中

              2. 在代码块中访问类成员
                  1. this.成员变量
                  2. this.成员方法
                  3. super.成员变量
                  4. super.成员方法
              3. 

   4. 继承的扩展
      1. 抽象类(上面已经学习):父类抽象点就是抽象类(如果有抽象方法,要求子类必须重写)
      2. 接口:再抽象点就是接口
         1) 定义语法
         [public] [abstract] interface 接口名称{
         [public] [static] [final] 数据类型 变量名;
         [public] [abstract]返回值类型 方法名();
         }
         2) 特点
         1. 接口的修饰符,默认是public abstract,写或不写,看你了
         1.
         2. 接口没有构造方法
         3. 要求成员变量是常量,方法是抽象方法
         1. 成员变量默认修饰符是:public static final,写或写多少,看你了
         2. 成员方法默认修饰符是:public staract,写或不写,看你了
         4. 类实现接口的语法(常用普通类,少用抽象类)
         class 类名 inplements 接口名1[,接口名2]{}
         表现的是have->a的关系
      3. 类与类的关系
         1) 继承关系,只能单继承,可以多层继承
      4. 类与接口
         1) 实现关系,可以单实现,也可多实现
         2) 可以在继承一个类的同时,实现多个接口
      5. 接口与接口
         1) 继承关系,可以多继承,也可多层继承
         1.
8. 多态特征
   1. 什么是多态
      1. 生活上:事务的多种形态
      2. 程序中:同一个引用类型，根据不同的实例而执行不同操作
         1)
   2. 多态的作用
      1. 让程序更加灵活多样
      2. 减少代码冗余
   3. 如何使用多态
      1. 使用多态前提条件
         1) 要有继承关系
         2) 要有方法重写
         3) 要有父类引用指向子类对象
      2. 定义方法参数的类型
      3. 定义方法返回值的类型
         1)
      4. 多态中成员访问的特点
         Pet pet1 = new Dog();Pet pet2 = new Cat();
         1) 对于成员变量和静态函数,编译和运行都看左边:访问的是父类的成员变量或静态函数
         2) 对于成员函数,编译看左边,运行看右边:访问的是重写后的函数
         1.
         3) 父类类型不能访问子类特有的函数或成员变量,如果要访问需要强制类型转换
         1.

转载于:https://www.cnblogs.com/River111/p/9552403.html