面向对象知识点简单总结

面向对象

面向对象编程：java是一门面向对象编程的语言

类和对象：对象是具体的事务，类是抽象的，类是对象的模板

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

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

  类：类型/类别，代表一类个体（是我们自己创造的一种数据类型）

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

• 类中可以包含：

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

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

• 如何创建类：在idea中新建一个类，可以取名为Student，在类中添加相应的属性和方法，这样就有了一个学生类

  public class Student {
      //成员变量
      String name;
      int age;
      String address;
      //方法
      void study(){
          System.out.println(name+"在学习...");
      }
      void sayHi(){
          System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
      }
  }
  

• 如何创建对象：用new关键字来创建一个新的对象

   Student zs = new Student();
  //new新对象时会给所有的成员变量赋默认值，规则如下
  byte,short,int,long,char-------------------0
  float,double-------------------------------0.0
  boolean------------------------------------false
  引用类型------------------------------------null
  

• 如何访问对象中的方法：将对象实例化后，可以通过变量名.方法进行访问

  zs.name = "zhangsan";
  zs.age = 25;
  zs.address = "河北廊坊";
   //调用方法
   zs.study();
  zs.sayHi();
  

方法：函数/过程

• 方法格式：修饰符 返回值类型 方法名（参数 参数名）{方法体 return：返回值；}

• 方法的作用：封装一段特定的业务逻辑功能，尽可能独立，一个方法只干一件事，方法可以被反复调用多次，可以减少代码重复，有利于代码维护，假设有一个功能，在很多地方都得使用，就将功能封装到一个方法中

• 方法的定义：

  //无参无返回值
  public static void say(){
      System.out.println("大家好，我叫xxx，今年38岁了");
  }
  //有参无返回值
  public static void sayHi(String name){ //形参
      System.out.println("大家好，我叫"+name+"，今年38岁了");
  }
  //有参无返回值
  public static void sayHello(String name,int age){ //形参
      System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
  }
  //无参有返回值
  public static double getNum(){
      //有返回值的方法中，必须有return
      //并且return后数据的类型还必须与返回值类型匹配
      return 8.88; //1)结束方法的执行  2)返回结果给调用方
  }
  //有参有返回值
  public static int plus(int num1,int num2){
      int num = num1+num2;
      return num; //返回的是num里面的那个数
      //return num1+num2; //返回的是num1与num2的和
  }
  //无参有返回值
  public static int[] testArray(){
      int[] arr = new int[10];
      for(int i=0;i<arr.length;i++){
          arr[i] = (int)(Math.random()*100);
      }
      return arr;
  }
  

• 方法的调用

  //无返回值：方法名(有参传参);
  say(); //调用say()方法
  sayHi("zhangsan"); //String name="zhangsan"  //实参
  sayHi("lisi"); //String name="lisi"          //实参
  //有返回值：数据类型  变量  =  方法名(有参传参);
  double a = getNum(); //getNum()的值就是return后的那个数
  System.out.println(a); //8.88，模拟对返回值的后续操作
  
  int b = plus(5,6); //plus(5,6)的值就是return后的那个数
  System.out.println(b); //11，模拟对返回值的后续操作
  
  

  注：只在方法中定义的参数叫形参，调用方法后的参数才是实参

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

  //方法重载的演示,仅为演示需要，正常操作中不会向下面这样写，类会单独分开
  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){} //编译错误，重载与参数名称无关
  }
  

• 方法的重写(override/overriding)：

  1. • 发生在父子类中，方法名相同，参数列表相同
     • 重写方法被调用时，看对象的类型
     • 重写需遵循"两同两小一大"原则：
       • 两同：
         • 方法名相同
         • 参数列表相同
       • 两小：
         • 派生类方法的返回值类型小于或等于超类方法的
           • void和基本类型时，必须相等
           • 引用类型时，小于或等于
         • 派生类方法抛出的异常小于或等于超类方法的
       • 一大：
         • 派生类方法的访问权限大于或等于超类方法的

  2. 重写与重载的区别：

     • 重写(override)：发生在父子类中，方法名相同，参数列表相同
     • 重载(overload)：发生在同一类中，方法名相同，参数列表不同

构造器：又称构造方法，构造函数

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

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

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

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

   this的用法：

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

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

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

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

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

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

  ​ 指针异常。

• JAVA规定：成员变量与局部变量是可以同名的，使用的时候默认采取的是就近原则，当成员变量和局部变量重名时，若想访问成员变量，则this不能省略

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

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

封装、继承、多态

封装：属性私有，get/set，我们的程序要追求高内聚（类的内部数据操作细节自己完成，不允许外部干涉）、低耦合（尽量暴露少量的方法给外部使用）

get：获得这个数据

set：给这个数据设置值

作用：1.提高代码的安全性，保护数据。2.隐藏代码的实现细节。3.统一接口。4.系统可维护性增加

继承：继承的本质是对某一批类的抽象，从而实现对显示世界更好的建模

• 作用：代码复用

• 通过extends来实现继承

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

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

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

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

• 具有传递性

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

  • 在派生类的构造方法中，若没有调用超类构造方法，则默认super()调用超类无参构造方法
  • 在派生类的构造方法中，若自己调用了超类构造方法，则不再默认提供

super注意点：1.super调用父类的构造方法，必须在构造方法的第一个2.super 必须且只能出现在子类的方法或构造方法中3.super和this不能同时调用构造方法，

this和super不同：1.代表对象不同：this，本身调用者的对象，super，代表父类对象的应用

2.前提：this，没有继承也可以使用；super只能在击沉干的条件下使用

3.构造方法：this（），本类构造；super（），父类构造

方法的重写： 1.方法名必须相同，参数列表必须相同，修饰符子类要大于父类，抛出异常子类只能小于父类，重写都是方法的重写，和属性无关。

多态

多态：多种形态

• 意义：

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

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

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

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

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

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

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

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

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

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

  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{  }
  

注意事项：1.多态是方法的多态，属性没有多态。2.父类和子类要有联系，否则会转换异常ClassCastExecption。3.存在条件：继承关系，方法需要重写，父类引用指向子对象；

无法被重写：static 方法，属于类，不属于实例；final 常量；private 方法

向上造型

向上造型：------------------------------------好处：代码复用

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

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

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

访问控制修饰符：保护数据的安全

1. • public：公开的，任何类

   • private：私有的，本类

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

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

     注意：

     java不建议默认权限，类的访问权限只能是public或默认的，类中成员的访问权限如上4种都可以

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

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

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

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

       ​ 通过引用打点来访问

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

       ​ 通过类名点来访问

2. final：最终的、不可改变的,可以当儿子，但是不能当爸爸

   • 修饰变量：变量不能被改变

     //演示final修饰变量
     class Eoo{
         final int a = 5;
         void show(){
             //a = 55; //编译错误，final的变量不能被改变
         }
     }
     

   • 修饰方法：方法不能被重写

     //演示final修饰方法
     class Foo{
         final void show(){}
         void test(){}
     }
     class Goo extends Foo{
         //void show(){} //编译错误，final的方法不能被重写
         void test(){}
     }
     

   • 修饰类：类不能被继承

     //演示final修饰类
     final class Hoo{}
     //class Ioo extends Hoo{} //编译错误，final的类不能被继承
     class Joo{}
     final class Koo extends Joo{} //正确，
     

3. static：静态的

   • 静态变量：

     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 何时用：所有对象所共享的数据(图片、音频、视频等)

   • 静态方法：

     • 由static修饰

     • 属于类，存储在方法区中，只有一份

     • 常常通过类名点来访问

     • 静态方法中没有隐式this传递，所以不能直接访问实例成员

     • 何时用：方法的操作与对象无关

       //演示静态方法
       class Moo{
           int a; //实例变量(对象来访问)
           static int b; //静态变量(类名点来访问)
           void show(){ //有this
               System.out.println(this.a);
               System.out.println(Moo.b);
           }
           static void test(){ //没有this
               //静态方法中没有隐式this传递，
               //没有this就意味着没有对象，
               //而实例变量a是必须通过对象点来访问的
               //所以如下语句发生编译错误
               //System.out.println(a); //编译错误
               System.out.println(Moo.b);
           }
       }
       
       //演示静态方法何时用
       class Noo{
           int a; //实例变量----是属于对象的，描述对象的属性
           //在show()中需要访问对象的属性a，说明此方法与对象有关，不能设计为静态方法
           void show(){
               System.out.println(a);
           }
           //在plus()中并没有访问对象的属性或行为，说明此方法与对象无关，可以设计为静态方法
           static int plus(int num1,int num2){
               int num = num1+num2;
               return num;
           }
       }
       
       public class StaticDemo {
           public static void main(String[] args) {
               Moo.test(); //常常通过类名点来访问
           }
       }
       

   • 静态块：

     • 由static修饰

     • 属于类，在类被加载期间自动执行，因为一个类只被加载一次，所以静态块也只执行一次

     • 何时用：加载/初始化静态资源(图片、音频、视频等)

       //演示静态块
       class Poo{
           static{
               System.out.println("静态块");
           }
           Poo(){
               System.out.println("构造方法");
           }
       }
       public class StaticDemo {
           public static void main(String[] args) {
               Poo o4 = new Poo();
               Poo o5 = new Poo();
               Poo o6 = new Poo();
           }
       }
       

4. 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; //编译错误，常量必须声明同时初始化
     }
     

abstract 抽象类

1. 抽象方法：

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

2. 抽象类：

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

3. 设计规则：

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

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

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

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

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

特点：不能new这个抽象类，只能靠子类去实现它，约束；抽象类中可以写普通方法，抽象方法必须写在抽象类中

内部类

1. 成员内部类：了解，应用率不高

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

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

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

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

     内部类中有一个隐式的引用指向创建它的外部类对象-----外部类名.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属性
             }
         }
     }
     

2. 匿名内部类：应用率高

   • 何时用：若想创建一个类(派生类)的对象，并且对象只被创建一次，可以设计为匿名内部类，可以大大简化代码操作
   • 在匿名内部类中不能修改外面局部变量的值，因为在此处该变量会被默认为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{
   }
   

接口

接口：

• 是一种引用数据类型

• 由interface定义

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

• 不能被实例化

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

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

• 接口可以继承接口

  /** 接口的演示 */
  public class InterfaceDemo {
      public static void main(String[] args) {
          //Inter5 o1 = new Inter5(); //编译错误，接口不能被实例化
          Inter5 o2 = new Doo(); //向上造型
          Inter4 o3 = new Doo(); //向上造型
      }
  }
  
  //演示接口继承接口
  interface Inter4{
      void show();
  }
  interface Inter5 extends Inter4{
      void test();
  }
  class Doo implements Inter5{
      public void test(){}
      public void show(){}
  }
  
  //演示接口的多实现
  interface Inter2{
      void show();
  }
  interface Inter3{
      void test();
  }
  abstract class Boo{
      abstract void say();
  }
  class Coo extends Boo implements Inter2,Inter3{
      public void show(){}
      public void test(){}
      void say(){}
  }
  
  //演示接口的实现
  interface Inter1{
      void show(); //默认访问权限为public的
      void test();
  }
  class Aoo implements Inter1{
      public void show(){} //重写接口中的抽象方法时，必须加public权限
      public void test(){}
  }
  
  //演示接口的语法
  interface Inter{
      //接口中成员的访问权限，默认就是public的，也只能是public的
      public static final int NUM = 5;
      public abstract void show();
      int COUNT = 5; //默认public static final
      void test(); //默认public abstract
      //int number; //编译错误，常量必须声明同时初始化
      //void say(){ } //编译错误，抽象方法不能有方法体
  }
  

  关系：

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

该内容仅用作学习和复习用，如有侵权联系删除，如有错误欢迎指正！