彻底掌握面向对象OO思想——跟学一遍，轻松搞定OO精髓

Java面向对象OO

1.类与对象

• 现实生活是由很多很多对象组成的，基于对象抽出了类

• 对象：软件中真实存在的单个的个体/东西

  类：类型/类别，代表一类个体

• 类是对象的模板/模子，对象是类的具体的实例

• 类中可以包含：

  • 对象的属性/特征/数据-----------------成员变量
  • 对象的行为/动作/功能-----------------方法

• 一个类可以创建多个对象

1. 如何创建类？如何创建对象？如何访问成员？

   //学生类
   public class Student {
       //成员变量
       String name;
       int age;
       String address;
       //方法
       void study(){
           System.out.println(name+"在学习...");
       }
       void sayHi(){
           System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
       }
   }
   
   //学生类的测试类
   public class StudentTest {
       public static void main(String[] args) {
           //创建一个学生对象
           Student zs = new Student();
           //给成员变量赋值
           zs.name = "zhangsan";
           zs.age = 25;
           zs.address = "河北廊坊";
           //调用方法
           zs.study();
           zs.sayHi();
   
           Student ls = new Student();
           ls.name = "lisi";
           ls.age = 24;
           ls.address = "黑龙江佳木斯";
           ls.study();
           ls.sayHi();
   
           //1)创建了一个学生对象
           //2)给所有成员变量赋默认值
           Student ww = new Student();
           ww.study();
           ww.sayHi();
       }
   }
   

2. 方法的签名：方法名+参数列表

3. 方法的重载(overload/overloading)：---------------------------大大方便用户的调用

   • 发生在同一类中，方法名相同，参数列表不同

   • 编译器在编译时会根据方法的签名自动绑定调用方法

     //方法重载的演示
     public class OverloadDemo {
         public static void main(String[] args) {
             Aoo o = new Aoo();
             o.show();
             o.show(25);
             o.show("zhangsan");
             o.show("zhangsan",25);
             o.show(25,"zhangsan");
         }
     }
     
     class Aoo{
         void show(){}
         void show(String name){}
         void show(int age){}
         void show(String name,int age){}
         void show(int age,String name){}
     
         //int show(){ return 1; } //编译错误，重载与返回值类型无关
         //void show(String address){} //编译错误，重载与参数名称无关
     }
     

   概念

4. OO：面向对象

   OOA：面向对象分析

   OOD：面向对象设计

   OOP：面向对象编程-------------------你们以后所参与的部分

5. 高质量的代码：-------------想拿年薪所必须的必

   • 复用性好、扩展性好、维护性好、可移植性好、健壮性好、可读性好、效率好…

6. 类：是一种引用数据类型(是我们自己创造的一种数据类型)

7. //          引用
   //数据类型 引用类型变量  指向      对象
     Student    zs        =   new Student();
   

8. new对象时会给所有成员变量赋默认值，规则如下：

   byte,short,int,long,char-------------------0
   float,double-------------------------------0.0
   boolean------------------------------------false
   引用类型------------------------------------null
   

2.构造方法

构造函数、构造器、构建器---------------复用给成员变量赋初始值代码

• 作用：给成员变量赋初始值
• 与类同名，没有返回值类型(连void都没有)
• 在创建(new)对象时被自动调用
• 若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了，则不再默认提供
• 构造方法可以重载

1. this：指代当前对象，哪个对象调用方法它指的就是哪个对象

   ​ 只能用在方法中，方法中访问成员变量之前默认有个this.

   this的用法：

   • this.成员变量名----------------------访问成员变量

     当成员变量和局部变量同名时，若想访问成员变量，则this不能省略

   • this.方法名()--------------------------调用方法(可以省略，没有什么情况下是不能省略)

   • this()------------------------------------调用构造方法(一般不用----了解)

2. null：表示空，没有指向任何对象。

   ​ 若引用的值为null，则该引用不能进行任何点操作了，若操作则发生NullPointerException空

   ​ 指针异常。

注意

1. 给成员变量赋初始值的代码写在构造方法中，其它业务代码还是去做普通方法

2. 成员变量：写在类中方法外，作用范围为整个类

   局部变量：写在方法中(包括方法的参数)，作用范围为当前方法

3. java规定：成员变量与局部变量是可以同名的，使用的时候默认采取的是就近原则

   当成员变量和局部变量同名时，若想访问成员变量，则this不能省略

4. 显示：?? related problems，表示有关联错误，不用管，找到编译错误位置改好就可以了

5. 内存管理：由JVM来管理的------今天初体验，面向对象第10天详细讲解

   • 堆：存储new出来的对象(包括成员变量)
   • 栈：存储局部变量(包括方法的参数)

6. 基本类型变量(变量)中装的是具体的数，引用类型变量(引用)中装的是对象

7. 异常：

   • ArrayIndexOutOfBoundsException：数组下标越界异常
   • NullPointerException：空指针异常

8. 引用类型数组：

• 给引用类型数组的元素赋值，需要new一下
• 若想访问对象的属性或调用方法，需要通过数组元素去打点

3.继承

• 作用：代码复用

• 通过extends来实现继承

• 父类：共有的属性和行为

  派生类/子类：特有的属性和行为

• 派生类既可以访问派生类的，也能访问父类的，但父类不能访问派生类的

• 一个父类可以有多个派生类，一个派生类只能继承一个父类-------单一继承

• 具有传递性

• java规定：构造派生类之前必须先构造父类

  • 在派生类的构造方法中，若没有调用父类构造方法，则默认super()调用父类无参构造方法

  • 在派生类的构造方法中，若自己调用了父类构造方法，则不再默认提供

    注意：super()调用父类构造方法，必须位于派生类构造方法的第一行

1. super：指代当前对象的父类对象

   super的用法：

   • super.成员变量名-----------------------------访问父类的成员变量

   • super.方法名()----------------------------------调用父类的方法

   • super()--------------------------------------------调用父类的构造方法

4.向上造型

------------------------------------好处：代码复用

• 超类型的引用指向派生类的对象

• 能点出来什么，看引用的类型-------------这是规定，记住就可以了

  多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代码复用

  eg: 学生/老师/医生都是输出名字+问好------干的事都一样，

  ​ 就可以将学生/老师/医生统一造型到Person数组中，这样一个for即可----代码复用

5.重写

1. (override/overriding)：重新写
   • 发生在父子类中，方法名相同，参数列表相同
   • 重写方法被调用时，看对象的类型---------------------这是规定，记住就可以了
   • 重写需遵循"两同两小一大"原则：------------------------ 了解，一般都是一模一样的
     • 两同：
       • 方法名相同
       • 参数列表相同
     • 两小：
       • 派生类方法的返回值类型小于或等于超类方法的
         • void和基本类型时，必须相等
         • 引用类型时，小于或等于
       • 派生类方法抛出的异常小于或等于超类方法的-----------------API时讲
     • 一大：
       • 派生类方法的访问权限大于或等于超类方法的-----------------明天讲
2. 重写与重载的区别：
   • 重写(override)：发生在父子类中，方法名相同，参数列表相同
   • 重载(overload)：发生在同一类中，方法名相同，参数列表不同

6.package

声明包

• 作用：避免类的命名冲突
• 同包中的类不能同名，但不同包中的类可以同名
• 类的全称：包名.类名，常常有层次结构
• 建议：包名所有字母都小写

import：导入类、引入类

• 同包中的类可以直接访问，但不同包中的类不参直接访问，若想访问：
  • 先import导入类再访问类-------建议
  • 类的全称-----------------------------太繁琐，不建议

注意：

1. 顺序问题：package----import----class

2. import 包名.*; 表示导入了包中的所有类，但不建议，建议用哪个类导哪个类

   ------因为.*会影响性能

7.访问控制修饰符

-----------------------------保护数据的安全

• public：公开的，任何类

• private：私有的，本类

• protected：受保护的，本类、派生类、同包类

• 默认的：什么也不写，本类、同包类

  注意：

  1. java不建议默认权限

  2. 类的访问权限只能是public或默认的

     类中成员的访问权限如上4种都可以

  3. 访问权限由大到小依次为：public–protected–默认的–private

1. final：最终的、不可改变的--------------------单独应用几率低
   • 修饰变量：变量不能被改变
   • 修饰方法：方法不能被重写
   • 修饰类：类不能被继承
2. static：静态的
   • 静态变量：
     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 何时用：所有对象所共享的数据(图片、音频、视频等)
   • 静态方法：
     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 静态方法中没有隐式this传递，所以不能直接访问实例成员
     • 何时用：方法的操作与对象无关
   • 静态块：
     • 由static修饰
     • 属于类，在类被加载期间自动执行，因为一个类只被加载一次，所以静态块也只执行一次
     • 何时用：加载/初始化静态资源(图片、音频、视频等)

注意

1. 数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)

2. 成员变量分两种：实例变量和静态变量

   • 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份

     ​ 通过引用打点来访问

   • 静态变量：由static修饰，属于类的，存储在方法区中，只有一份

     ​ 通过类名点来访问

3. 内存管理：由JVM管理的

   • 堆：new出来的对象(包括实例变量、数组的元素)
   • 栈：局部变量(包括方法的参数)
   • 方法区：.class字节码文件(包括静态变量、所有方法)

4. 一般情况下：凡是静态的成员，都是公开的

8.static final常量

• 必须声明同时初始化

• 常常由类名点来访问，不能被改变

• 建议：常量所有字母都大写，多个单词用_分隔

• 编译器在编译时会将常量直接替换为具体的值，效率高

• 何时用：数据永远不变，并且经常使用

  public class StaticFinalDemo {
      public static void main(String[] args) {
          System.out.println(Aoo.PI); //常常通过类名点来访问
          //Aoo.PI = 3.1415926; //编译错误，常量不能被改变
  
  
          //1)加载Boo.class到方法区中
          //2)静态变量num一并存储在方法区中
          //3)到方法区中获取num的值并输出
          System.out.println(Boo.num);
  
          //编译器在编译时会将常量直接替换为具体的值，效率高
          //相当于System.out.println(5);
          System.out.println(Boo.COUNT);
  
      }
  }
  
  class Boo{
      public static int num = 5; //静态变量
      public static final int COUNT = 5; //常量
  }
  
  class Aoo{
      public static final double PI = 3.14159;
      //public static final int NUM; //编译错误，常量必须声明同时初始化
  }
  

1. 抽象方法：

   • 由abstract修饰
   • 只有方法的定义，没有具体的实现(连{}都没有)

2. 抽象类：

   • 由abstract修饰
   • 包含抽象方法的类必须是抽象类
   • 抽象类不能被实例化
   • 抽象类是需要被继承的，派生类：
     • 重写抽象方法(变不完整为完整)-----------一般做法
     • 也声明为抽象类-------------------------------一般不这么做
   • 抽象类的意义：
     • 封装共有的属性和行为--------------------代码复用
     • 为所有派生类提供统一的类型-----------向上造型(代码复用)
     • 可以包含抽象方法，为所有派生类提供统一的入口(造型之后能点出来)，同时可以达到强制必须重写的目的(相当于制定一个规则)

3. 设计规则：

   • 将共有的属性和行为，抽到超类中------------------------抽共性

   • 若派生类的行为都一样，设计为普通方法

     若派生类的行为都不一样，设计为抽象方法

4. 抽象方法/抽象类的疑问：

   • 抽象方法存在的意义是什么？
     • 保证当发生向上造型时，通过超类的引用能点出来那个方法-------保证能点出方法来
   • 既然抽象方法的意义是保证能点出来，那为什么不设计为普通方法呢？
     • 设计为普通方法，意味着派生类可以重写也可以不重写，但设计为抽象方法，可以强制派生类必须重写--------------强制派生类重写的目的

9.成员内部类

• 类中套类，外面的称为外部类，里面的称为内部类

• 内部类只服务于外部类，对外不具备可见性

• 内部类对象通常在外部类中创建

• 内部类中可以直接访问外部类的成员(包括私有的)，

  内部类中有一个隐式的引用指向创建它的外部类对象-----外部类名.this—后面API中会用

  //成员内部类的演示
  public class InnerClassDemo {
      public static void main(String[] args) {
          Mama m = new Mama();
          //Baby b = new Baby(); //编译错误，内部类对外不具备可见性
      }
  }
  
  class Mama{ //外部类
      private String name;
      void create(){
          Baby b = new Baby(); //正确，内部类对象通常在外部类中创建
      }
      class Baby{ //成员内部类
          void showName(){
              System.out.println(name); //简写
              System.out.println(Mama.this.name); //完整写法
              //System.out.println(this.name); //编译错误，当前Baby类没有name属性
          }
      }
  }
  

10.匿名内部类

• 何时用：若想创建一个类(派生类)的对象，并且对象只被创建一次，可以设计为匿名内部类，可以大大简化代码操作
• 在匿名内部类中不能修改外面局部变量的值，因为在此处该变量会被默认为final的—API时用
• 小面试题：
  • 问：内部类有独立的.class字节码文件吗？
  • 答：有

//匿名内部类的演示
public class NstInnerClassDemo {
    public static void main(String[] args) {
        //1)创建了Aoo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o1----向上造型为Aoo类型
        //  ---new Aoo(){}是在创建Aoo的派生类的对象
        //3)大括号中的为派生类的类体
        Aoo o1 = new Aoo(){
        };

        //1)创建了Aoo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o2----向上造型为Aoo类型
        //  ---new Aoo(){}是在创建Aoo的派生类的对象
        //3)大括号中的为派生类的类体
        Aoo o2 = new Aoo(){
        };

        int num = 5;
        num = 55;
        //1)创建了Boo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o3----向上造型为Boo类型
        //3)大括号中的为派生类的类体
        Boo o3 = new Boo(){
            void show(){
                System.out.println("showshow");
                //num = 55; //在此处会默认外面的局部变量num为final的
            }
        };
        o3.show();
    }
}

abstract class Boo{
    abstract void show();
}

abstract class Aoo{
}

1. 隐式引用：
   • this：指代当前对象
   • super：指代当前对象的超类对象
   • 外部类名.this：指代当前对象的外部类对象
2. 做功能的套路：----------------------最最最最重要的一个内容
   • 先写行为/功能/方法：
     • 若为某个对象所特有的行为/功能，就将方法设计在特定的类中
     • 若为对象所共有的行为/功能，就将方法设计在超类中

11.接口

• 是一种引用数据类型

• 由interface定义

• 只能包含常量和抽象方法

• 不能被实例化

• 接口是需要被实现/继承的，实现类/派生类：必须重写接口中的所有抽象方法

• 一个类可以实现多个接口，用逗号分隔。若又继承又实现时，应先继承后实现

• 接口可以继承接口]

  注意

1. 接口中成员的访问权限，默认就是public的，也只能是public的

2. 接口中的数据默认都是常量，方法默认都是抽象的

3. 关系：

   • 类和类--------------------------------继承
   • 接口和接口--------------------------继承
   • 类和接口-----------------------------实现

4. 设计规则：

   • 将所有派生类所共有的属性和行为，抽到超类中------------------------抽共性

   • 若派生类的行为都一样，设计为普通方法

     若派生类的行为都不一样，设计为抽象方法

   • 将部分派生类所共有的属性和行为，抽到接口中

     接口是对继承的单根性的扩展-------------------------------实现多继承

     接口是一个标准、一种规范，实现了接口就能干那个事，不实现接口就干不了那个事

12.多态

多种形态

• 意义：

  • 同一个对象被造型为不同的类型时，有不同的功能------所有对象都是多态的(明天详细理解)

    ----对象多态：我、你、水…

  • 同一类型的引用指向不同的对象时，有不同的实现------所有抽象方法都是多态的

    ----行为多态：cut()、getImage()、move()、getScore()…

• 向上造型/自动类型转换：

  • 超类型的引用指向派生类的对象(前面是超类型，后面是派生类型)
  • 能点出来什么，看引用的类型(这是规定)
  • 能向上造型成为的类型有：超类+所实现的接口

• 强制类型转换，成功的条件只有如下两种：

  • 引用所指向的对象，就是该类型
  • 引用所指向的对象，实现了该接口或继承了该类

• 强转若不符合如上条件，则发生ClassCastException类型转换异常

  建议：在强转之前一定要先通过instanceof来判断引用的对象是否是该类型

  强转时若符合如上的两个条件，则instanceof返回true，若不符合则返回false

  何时需要强转：你想访问的东西在超类中没有，那就需要强转

  public class MultiType {
      public static void main(String[] args) {
          //条件1:引用所指向的对象，就是该类型
          //条件2:引用所指向的对象，实现了该接口或继承了该类
          Aoo o = new Boo(); //向上造型
          Boo o1 = (Boo)o;     //引用o所指向的对象，就是Boo类型-------符合条件1
          Inter o2 = (Inter)o; //引用o所指向的对象，实现了Inter接口---符合条件2
          //Coo o3 = (Coo)o; //运行时会发生ClassCastException类型转换异常
  
          //判断o是否是Coo类型(与强转成功条件完全匹配)
          if(o instanceof Coo){ //false
              Coo o4 = (Coo)o; //instanceof若为true，则强转一定成功
          }else{
              System.out.println("o不是Coo类型");
          }
  
      }
  }
  interface Inter{  }
  class Aoo{  }
  class Boo extends Aoo implements Inter{  }
  class Coo extends Aoo{  }
  

13.内存管理

由JVM来管理的----------我笔记里面有哪些就先记哪些

• 堆：

  • 存储的是new出来的对象(包括实例变量、数组的元素)

  • 垃圾：没有任何引用所指向的对象

    垃圾回收器(GC)不定时到堆中清扫垃圾，回收过程是透明的(看不到的)，并不一定一发现垃圾就立刻回收，通过调用System.gc()建议虚拟机尽快调度GC来回收

  • 实例变量的生命周期：

    ​ 在创建时对象时存储在堆中，对象被回收时一并被回收

  • 内存泄漏：不再使用的对象还没有被及时的回收，严重的泄漏会导致系统的崩溃

    建议：不再使用的对象应及时将引用设置为null

• 栈：

  • 存储正在调用的方法中的局部变量(包括方法的参数)

  • 调用方法时会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量(包括方法的参数)，方法调用结束时，栈帧被自动清除，局部变量一并被清除

  • 局部变量的生命周期：

    ​ 调用方法时存储在栈中，方法调用结束时与栈帧一并被清除

• 方法区：

  • 存储.class字节码文件(包括静态变量、所有方法)
  • 方法只有一份，通过this来区分具体的调用对象

1. 面向对象三大特征总结：-------------非常重要，一定要记住

   • 封装：

     • 类：封装的是对象的属性和行为
     • 方法：封装的是具体的业务逻辑功能实现
     • 访问控制修饰符：封装的是具体的访问权限

   • 继承：

     • 作用：代码复用

     • 超类：所有派生类所共有的属性和行为

       接口：部分派生类所共有的属性和行为

       派生类：派生类所特有的属性和行为

     • 单一继承、多接口实现，具有传递性

   • 多态：

     • 所有对象都是多态的----------------通过向上造型来体现的

       所有抽象方法都是多态的----------通过方法的重写来体现的

     • 向上造型、强制类型转换、instanceof判断

2. String：字符串类型

   • java.lang.String使用final修饰，不能被继承

   • String的底层封装的是一个字符数组

   • String在内存中采用Unicode编码格式，每个字符占用两个字节的空间

   • 字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值(指向新的对象)

     --------不变对象