Java基础7 ---- 面向对象基础

面向对象

对象的创建分析

public class Demo06 {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();

        student.name();
    }
}

class Student{
    // 属性
    String name;
    int age;

    // 方法
    public void say() {
        System.out.println("say");
    }
    public void name() {
        System.out.println(name);
    }
}

构造器

• 默认

• 无参数

• 有参数

class Student{
    // 构造函数
    public Student(String name) {
        this.name = name;
    }
    // 属性
    String name;
    int age;

    // 方法
    public void say() {
        System.out.println("say");
    }
    public void name() {
        System.out.println(name);
    }
}

IDEA中使用 “alt + insert" 可以自动生成构造器

面向对象的三大特性（核心）

• 封装

• 继承：extends关键字

  public class Demo07 {
      public static void main(String[] args) {
          Gradute stu = new Gradute();
          stu.setId(2000);
          System.out.println(stu.id);
      }
  }
  
  class Person{
      String name;
      int age;
  }
  
  
  class Gradute extends Person{
      int id;
  
      public int getId() {
          return id;
      }
  
      public void setId(int id) {
          this.id = id;
      }
  }
  

• 多态

  public class Demo07 {
      public static void main(String[] args) {
          Person stu = new Graduate();
          stu.setAge(15);
          System.out.println(stu.age);
      }
  }
  
  class Person{
      String name;
      int age;
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
  }
  
  
  class Graduate extends Person{
      int id;
  
      public int getId() {
          return id;
      }
  
      public void setId(int id) {
          this.id = id;
      }
  }
  

  父类引用指向子类对象

抽象类和接口

1. 抽象类

   abstract关键字

   抽象类的所有方法，继承了它的子类，都必须要实现方法（除非其子类也是抽象类）

   public class Demo08 extends Man {
       @Override
       public void f() {
           
       }
   }
   
   //抽象类
   abstract class Man{
       
       public abstract void f();
   }
   

   1. 抽象类不能new, 只能通过子类继承过来
   2. 有抽象方法的类必须是抽象类，抽象类可以有非抽象方法

2. 接口

   接口的本质是契约，是oo的精髓。

   关键字：interface

   实现了接口的类就要重写接口中的方法。

   public interface Demo09 {
       // 接口中所有定义均默认为public abstract
       void f(String name);
   }
   

   1. public abstract
   2. public static final
   3. 接口不能被实例化
   4. implement关键字实现接口(可“多继承”)
   5. 必须要重写接口中的方法

内部类及oop实战