Java基础 - 面向对象

面向对象

1、概念

• 面向对象编程（Object-Oriented Programming,OOP）
  • 本质：以类的方式组织代码，以对象的组织(封装)数据
• 类是对象的模版，对象是具体的，类是抽象的

2、对象的建立分析

变量类型 变量名 = 值
Student mo = new Student()

• 使用new关键字建立对象时，会对建立好的对象进行默认初始化，分配内存空间，以及对类中构造器的调用

  • 类的构造器：又称构造方法，在建立对象时必需要调用的

    • 快捷键：Alt+Ins

    • 特色：

      1. 必须和类的名字相同
      2. 必须没有返回类型，也不能写void

    • 做用：

      1. 使用new关键字，本质是在调用构造器
      2. 用来初始化值

    • 划分：

      1. 无参构造

         public class Creation {
             String name;
             public Creation(){
                 this.name = "mo";
             } 
             public static void main(String[] args) {
                 Creation creation = new Creation();
                 System.out.println(creation.name);		//mo
             }
         }

      2. 有参构造

         public class Creation {
             String name;
          public Creation(){}             //无参构造【加上无参构造，new时既可带参数，也可不带参数】
              public Creation(String na){       //有参构造
                  this.name = na;
              }
              public static void main(String[] args) {
                  Creation creation = new Creation("mo");
                  System.out.println(creation.name);		//mo
              }
         }

3、面向对象的三大特性

封装

• 数据的隐藏【应禁止直接访问一个对象中数据的实际表示，而应经过操做接口来访问】
• 程序设计追求“高内聚，低耦合”
  • 高内聚：类的内部数据操做细节本身完成，不容许外不干涉
  • 低耦合：仅暴露少许的方法给外部使用
• 做用
  • 提升了程序的安全性，保护数据
  • 隐藏代码的实现细节
  • 统一接口
  • 系统可维护性增长
• 快捷键：Alt+Ins

public class Packaging {
    private String name;
    private int age;
    public String getName(){    		//get得到这个数据
        return this.name;
    }
    public void setName(String name){	//set设置这个数据
        this.name = name;
    }
    public int getAge(){
        return this.age;
    }
    public void setAge(int age){
        if (age>=0 && age<=120){
            this.age = age;
        }else {
            this.age = 3;
        }
    }
    public static void main(String[] args) {
        Packaging packaging = new Packaging();
        packaging.setName("mo");
        System.out.println(packaging.getName());	//mo
        packaging.setAge(6);
        System.out.println(packaging.getAge());		//6
    }
}

继承

• 继承是类与类之间的关系，一个为子类(派生类)、父类(基类)

  • 子类继承父类，使用关键字 extends 表示
  • 子类继承父类，会拥有父类全部方法，但私有属性、方法不能继承
  • java中类只有单继承，没有多继承

• 快捷键：Ctrl+H

• Object类

  • 全部的类都默认直接或间接继承Object

• super

  • super调用父类的构造方法，必须在构造方法的第一个
  • 子类构造器中默认调用了父类构造器，且若显示的话，必须放在子类构造器的第一行，不然会报错

public class Blank{
    public static void main(String args[]){
        Student student = new Student();        //同时调用了子类无参构造和父类无参构造
        student.eat();
    }
}

class Person{
    public Person(){
        System.out.println("person的无参构造在调用");
    }
    public void eat(){
        System.out.println("person正在吃·····");
    }
}
class Student extends Person{
    public Student(){
        //隐藏代码，调用子类构造器时会默认调用父类的无参构造
        super();  //若是显示父类的无参构造，要放在子类无参构造的第一行    //person的无参构造在调用
        System.out.println("student的无参构造在调用");              //student的无参构造在调用
    }
    public void eat(){
        super.eat();                                       //"person正在吃·····"
        System.out.println("Student正在吃·····");                //"Student正在吃·····"
    }
}

• 方法重写【override】

  • 方法名相同，方法体不一样
  • 快捷键：Alt+Ins
  • 前提：须要有继承关系，子类重写父类的方法
  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可扩大，但不能缩小 【Public>Protected>Default>Private】
  4. 抛出的异常：范围能够缩小，但不能扩大【Exception(大)】
  • 不能进行方法重写
    • static 方法，属于类，不属于实例
    • final 常量
    • private 私有

多态

• 多态：同一方法能够根据发送对象的不一样而采用多种不一样的行为方式

  • 一个对象的实际类型是肯定的，但能够指向对象的引用类型有不少

• 存在条件

  • 须要有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象【father f1 = new son()】

  public class Polymorphic {
      public static void main(String[] args) {
          student s1 = new student();
          Person s2 = new student();
          Object s3 = new student();
  
          s1.eat();   //st_eat
          s2.eat();   //st_eat        子类重写父类的方法，执行子类的方法
          ((student) s2).run();   //st_run        父类不能调用子类独有的方法，但能够将父类强制转为子类(高转低)，执行子类的方法
      }
  }
  
  class Person{
      public void eat(){
          System.out.println("Pe_eat");
      }
  }
  
  class student extends Person{
      public void eat(){
          System.out.println("st_eat");
      }
      public void run(){
          System.out.println("st_run");
      }
  }

• A instanceof B -> 用于判断A是不是B的实例

  • 由于new Student()，故三个实例对象的实际类型都是Student，student的父类都会返回true
  • 同时因为存在引用类型的不一样，与引用类型相联系返回false，无联系则会报错

• 类型转换【父(高) -> 子(低)：强制转换】【子 -> 父：自动转换，但可能丢失子类中独有的方法】

//Person是Student的父类
Person obj = new Student();
Student student = (Student)obj	//强制转换，并赋值
student.eat()		//转换后就可使用子类的方法

4、抽象类

​ 修饰符 abstract，修饰方法则为抽象方法，修饰类则为抽象类

​ 抽象的抽象：约束

• 抽象类中能够没有抽象方法，但有抽象方法的类必定要声明为抽象类
• 抽象类中能够有具体方法
• 抽象类不能使用 new 来建立对象，它是用来让子类继承的
• 抽象方法只有方法的声明，没有方法的实现，它是用来让子类实现的
• 子类继承抽象类，那么就必需要实现抽象类没有实现的抽象方法，不然该子类也要声明为抽象类

public class Abstract {
    public static void main(String[] args) {
        //new up1()   //报错：'up1' is abstract; cannot be instantiated
    }
}

abstract class up1{
    public abstract void doSomething();     //抽象方法，只有方法名字，没有方法的实现
}

class up2 extends up1{      //子类继承抽象类，要对抽象方法进行重写
    @Override
    public void doSomething() {
    }
}

5、接口

• 接口本质是契约、规范，本身没法写方法

• 声明类的关键字是class，声明接口的关键字是interface

• 类经过implements继承接口，进行实现

  • 接口能够多继承
  • 继承接口的类的类名一般以Impl结尾
  • 类继承接口后，要对接口中的方法进行重写

6、内部类及OOP实战

• 内部类：在一个类的内部再定义一个类

  【A类中定义B类，B就为A的内部类，A为B的外部类】

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类