Java基础 - 面向对象

面向对象

一、概念

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

二、对象的创建分析

变量类型 变量名 = 值
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
     }
}

三、面向对象的三大特性

封装

  • 数据的隐藏【应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问】
  • 程序设计追求“高内聚，低耦合”
    • 高内聚：类的内部数据操作细节自己完成，不允许外不干涉
    • 低耦合：仅暴露少量的方法给外部使用
  • 作用
    • 提高了程序的安全性，保护数据
    • 隐藏代码的实现细节
    • 统一接口
    • 系统可维护性增加
  • 快捷键：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的实例

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

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

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

四、抽象类

​ 修饰符 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() {
    }
}

五、接口

  • 接口本质是契约、规范，自己无法写方法

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

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

    • 接口可以多继承
    • 继承接口的类的类名通常以Impl结尾
    • 类继承接口后，要对接口中的方法进行重写
    image-20210209153515822

六、内部类及OOP实战

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

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

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类
posted @ 2021-02-19 17:45  葬花骨  阅读(54)  评论(0)    收藏  举报