（java）面向对象（下）

封装

• 该露的露，该藏的藏

  • 程序设计要追求”高内聚，低耦合“。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用

• 封装（数据的隐藏）

  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

• 属性私有：get/set

• Student类：

  package com.xd.base;
  ​
  //学生类
  public class Student {
  ​
      //private 私有化
      private String name;
      private int id;
      private int age;
      private char sex;
  ​
      //提供一些可以操作这个属性的方法
      //提供一些public的get/set方法
      //get 获得这个数据
      public String getName(){
          return this.name;
      }
  ​
      //set 给这个数据设置值
      public void setName(String name){
          this.name = name;
      }
  ​
      public int getId() {
          return id;
      }
  ​
      public void setId(int id) {
          this.id = id;
      }
  ​
      public int getAge() {
          return age;
      }
  ​
      public void setAge(int age) {
          if (age>100 || age<0){
              this.age = 0;
          }
          else {
              this.age = age;
          }
      }
  ​
  }

• main类：

  package com.xd.base;
  ​
  //一个项目应该只存有一个main方法
  public class Alltext {
      public static void main(String[] args) {
          Student student = new Student();
          //student.name = "sss";
          System.out.println(student.getName());
          student.setName("xd");
          System.out.println(student.getName());
          student.setAge(4);
          System.out.println(student.getAge());
          student.setAge(888);
          System.out.println(student.getAge());
  ​
  ​
      }
  }
  ​
  null
  xd
  4
  0
  ​
  Process finished with exit code 0

• 封装的意义：

  1. 提高程序的安全性，保护数据

  2. 隐藏代码的实现细节

  3. 统一接口

  4. 系统可维护增加了

继承

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

• extands的意思是”扩展“。子类是父类的扩展

• Java中类只有单继承，没有多继承

• 继承是类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示

• 子类和父类之间，从意义上讲应该具有”is a“的关系

 

• object类

• super

• 方法重写

 

• People类：

  package com.xd.base;
  ​
  //在Java中，所有的类，都默认直接或间接继承object
  //人
  public class People {
      private double money;
      public void say() {
          System.out.println("People is say");
      }
  ​
      public double getMoney() {
          return money;
      }
  ​
      public void setMoney(double money) {
          this.money = money;
      }
  }

• Student类：

  package com.xd.base;
  ​
  //学生类
  public class Student extends People{
      //ctrl + H 显示继承关系
  }

• main类：

  package com.xd.base;
  ​
  //一个项目应该只存有一个main方法
  public class Alltext {
      public static void main(String[] args) {
  ​
          Student student = new Student();
          student.say();
          student.setMoney(10_0000);
          System.out.println(student.getMoney());
  ​
      }
  }

super

• 父类：

  package com.xd.base;
  ​
  //在Java中，所有的类，都默认直接或间接继承object
  //人
  public class People {
      public People(){
          System.out.println("父类的无参构造运行");
      }
      protected String name = "father lei name";
      public void print(){
          System.out.println("father print");
      }
  }

• 子类：

  package com.xd.base;
  ​
  //学生类
  public class Student extends People{
      public Student(){
          //隐藏代码：调用父类的无参构造
          //在子类建立时，先构造父类
  ​
          //super();    //调用父类的构造器，必须要在子类构造器的第一行
          System.out.println("子类的无参构造运行");
      }
  ​
      private String name = "son lei name";
  ​
      public void print(String name){
          System.out.println(name);
          System.out.println(this.name);
          System.out.println(super.name);
      }
  ​
      public void print(){
          System.out.println("son print");
      }
  ​
      public void text(){
          print();
          this.print();
          super.print();
      }
  ​
  }

• main类：

  package com.xd.base;
  ​
  //一个项目应该只存有一个main方法
  public class Alltext {
      public static void main(String[] args) {
          System.out.println("=================================");
          Student student = new Student();
          System.out.println("=================================");
          student.print("main lei print name");
          System.out.println("=================================");
          student.text();
      }
  }

• super注意点

  1. super 调用父类构造方法，必须在构造方法的第一个

  2. super 必须只能出现在子类的方法或者构造方法中

  3. super 和 this 不能同时调用构造方法

• 对比

  • this：本身调用这个对象

  • super：代表父类对象的调用

• 前提

  • this：没有继承也可以使用

  • super：只能在继承条件可以使用

• 构造方法

  • this()：本类的构造

  • super()：父类的构造

方法重写

• 需要有继承关系，子类重写父类的方法

  1. 方法名必须相同

  2. 参数列表必须相同

  3. 修饰符：范围可以扩大：public > Protected > Default > private

  4. 抛出的异常：范围 可以被缩小，但不能扩大： ClassNotFoundException --> Exception（大）

• 子类的方法和父类必要一致，方法体不同

• 为什么需要重写：

  1. 父类的功能，子类不一定需要，或者不一定满足

  2. Alt + Insert；override；

• People：

  package com.xd.base;
  
  //重写都是方法的重写，和属性无关
  public class People {
  
      public static void test(){
          System.out.println("People->test");
      }
  
      public void no_static_test(){
          System.out.println("People.no.static.test");
      }
  
  }

• Student：

  package com.xd.base;
  
  //学生类
  public class Student extends People{
  
      public static void test(){
          System.out.println("student->test");
      }
  
      @Override
      public void no_static_test() {
          System.out.println("Student.no.static.test");
      }
  }

• main：

  package com.xd.base;
  
  //一个项目应该只存有一个main方法
  public class Alltext {
      public static void main(String[] args) {
  
          //静态方法和非静态方法区别很大
          //静态方法 +static
          Student student = new Student();
          student.test();//走的是Student的方法
  
          People student1 = new Student();
          student1.test();//走的是People的方法
  
          System.out.println("=====================================");
  
          //去掉static alt+insert 重写之后，输出都为student方法
          //非静态方法 无static
          Student student2 = new Student();
          student.no_static_test();//走的是Student的方法
  
          People student3 = new Student();
          student1.no_static_test();//走的是People的方法
  
          People people = new People();
          people.no_static_test();
  
      }
  }

多态

• 动态编程：类型：可扩展性

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

• 多态存在的条件

  1. 有继承关系

  2. 子类重写父类方法

  3. 父类引用指向子类对象

• 多态注意事项：

  1. 多态是方法的多态，属性没有多态

  2. 父类和子类，有联系，类型转换异常 ClassCastException！

  3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象

• 有些方法不能被重写：

  1. static，静态方法，属于类，不属于实例

  2. final 常量

  3. private 方法，私有

• People：

  package com.xd.base;
  
  //重写都是方法的重写，和属性无关
  public class People {
      public  void run(){
          System.out.println("run()");
      }
  }

• Student：

  package com.xd.base;
  
  //学生类
  public class Student extends People{
      public  void run(){
          System.out.println("son run()");
      }
  
      public void eat(){
          System.out.println("eat");
      }
  
  }

• main：

  package com.xd.base;
  
  //一个项目应该只存有一个main方法
  public class Alltext {
      public static void main(String[] args) {
  
          //一个对象的实际类型是确定的
  
          //可以指向的引用类型就不确定了:父类的引用指向子类
  
          //Student能调用的方法都是自己的或者父类的
          Student s1 = new Student();
          //People 父类型，可以指向子类，但不能调用子类独有的方法
          People s2 = new Student();
          Object s3 = new Student();
  
          s1.run();
          s2.run();
  
          s1.eat();
  
  
          //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
  
  
      }
  }

instanceof

• 类型转换，引用类型，判断一个对象是什么类型

• 判断两个类之间是否存在父子关系

• 总结：

  1. 父类引用指向子类的对象

  2. 把子类转换为父类，向上转型

  3. 把父类转换成子类，强制转换

  4. 方便方法的调用，减少重复代码，简洁

• 抽象：封装，继承，多态

• 抽象类，接口

• People：

  package com.xd.base;
  
  //重写都是方法的重写，和属性无关
  public class People {
  
  }

• Student：

  package com.xd.base;
  
  //学生类
  public class Student extends People{
      public void run_Student(){
          System.out.println("run_Student方法");
      }
  
  }

• Teacher：

  package com.xd.base;
  
  public class Teacher extends People{
  }

• main：

  package com.xd.base;
  
  public class Alltext {
      public static void main(String[] args) {
  
          Object object = new Student();
  
          System.out.println(object instanceof Student);
          System.out.println(object instanceof People);
          System.out.println(object instanceof Object);
          System.out.println(object instanceof Teacher);
          System.out.println(object instanceof String);
  
          System.out.println("====================================");
  
          People people = new Student();
  
          System.out.println(people instanceof Student);
          System.out.println(people instanceof People);
          System.out.println(people instanceof Object);
          System.out.println(people instanceof Teacher);
          //System.out.println(people instanceof String);
  
          System.out.println("====================================");
  
          Student student = new Student();
  
          System.out.println(student instanceof Student);
          System.out.println(student instanceof People);
          System.out.println(student instanceof Object);
          //System.out.println(student instanceof Teacher);
          //System.out.println(student instanceof String);
  
          System.out.println("====================================");
          //类型转换
          /**
           * 在student中写一个独有的runStudent方法，new一个引用People的的对象a
           * 想要使a可以用runStudent方法，则要将a强制转换为Student类型
           */
          People a = new Student();
          //a.runStudent();
          ((Student) a).run_Student();
          //a.run_Student();
  
      }
  }
  
  true
  true
  true
  false
  false
  ====================================
  true
  true
  true
  false
  ====================================
  true
  true
  true
  ====================================
  run_Student方法
  
  Process finished with exit code 0

static

package com.xd.base;


public class Student extends People{

    private static int age;//静态变量 多线程
    private double score;//非静态变量

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {

        Student s1 = new Student();

        System.out.println(Student.age);
        //System.out.println(Student.score);//非静态不能这样用
        System.out.println(s1.age);
        System.out.println(s1.score);
        //非静态方法可以访问静态方法，静态不能调用非静态方法

    }

}

• 静态代码块

  package com.xd.base;
  
  import java.time.Period;
  
  public class Alltext {
  
      //静态代码块
      //赋初始值
      {
          //代码块（匿名代码块）
          System.out.println("匿名代码块");
      }
  
      //只执行一次
      static {
          //静态代码块
          //永久只执行一次
          System.out.println("静态代码块");
      }
      public Alltext(){
          System.out.println("构造方法");
      }
  
      public static void main(String[] args) {
          Alltext alltext = new Alltext();
          System.out.println("==================================");
          Alltext alltext1 = new Alltext();
      }
  
  }

抽象类

• abstract修饰符可以用来修饰方法，也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类

• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

• 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的

• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的

• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

• 注意：

  1. 不能new这个抽象类，只能靠子类去实现它，约束

  2. 抽象类中可以写普通方法

  3. 抽象方法必须写在抽象类中

  4. 抽象的抽象 约束

接口

• 普通类：只有具体实现

• 抽象类：具体实现和规范（抽象方法）都有

• 接口：只有规范

 

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。

• 接口的本质是契约，制定好后大家要遵守

• 接口的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言，就是因为设计模式所研究的，实际上就是如何合理的去抽象

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

• 接口UserService：

  package com.xd.demo01;
  
  //抽象思维 Java架构
  //interface:定义的关键字，接口都需要有一个实现类 
  public interface UserService {
      //接口中的所有定义其实都是抽象的：public abstract,可以直接写 返回值类型加名字加参数 void run();
      
      //常量
      public static final int AGE = 100;
      
      void add(String name);
      void delete(String name);
      void update(String name);
      void query(String name);
  }

• 接口TimeService：

  package com.xd.demo01;
  
  public interface TimeService {
      void timer();
  }

• class：

  package com.xd.demo01;
  
  //抽象类：extends
  //类 可以实现接口implements 接口
  //实现了接口的类，就需要重写接口中的方法
  //
  //多继承 利用接口实现多继承
  public class UserServiceIMPL implements UserService , TimeService{
      @Override
      public void add(String name) {
  
      }
  
      @Override
      public void delete(String name) {
  
      }
  
      @Override
      public void update(String name) {
  
      }
  
      @Override
      public void query(String name) {
  
      }
  
      @Override
      public void timer() {
  
      }
  }

• 作用：

  1. 约束

  2. 定义一些方法，让不同人实现

  3. public abstract

  4. public stativc final

  5. 接口不能被实例化，接口没有构造方法

  6. implement可以实现多个接口

  7. 必须要重写接口中的方法

内部类

• 内部类就是在一个类的内部在定义一个 类，比如A类中定义一个B类，那么B类对于A类来说就称之为内部类，而A类相对于B类来说就是外部类

 

• 成员内部类

• 静态内部类

• 局部内部类

• 匿名内部类

• Outer：

  package com.xd.demo02;
  
  public class Outer {
  
      private int id = 0000111;
      public void out(){
          System.out.println("外部类的方法");
      }
  
      class Inner{
          public void in(){
              System.out.println("内部类的方法");
          }
  
          //内部类访问外部变量的私有变量
          public void getID(){
              System.out.println(id);
          }
          
      }
      
      //局部内部类
      public void method(){
          class Inner{
              public void in(){
                  
              }
          }
      }
  
  }
  
  //一个java类中可以有多个class文件，但是只能有一个public class
  class A{
      public static void main(String[] args) {
          Outer outer = new Outer();
          //通过这个外部类来实例化内部类
          Outer.Inner inner = outer.new Inner();
          inner.in();
          inner.getID();
      }
  }
  
  class B{}
  class C{}
  class D{}
  class E{}
  class F{}
  class G{}

• Test：

  package com.xd.demo02;
  
  public class Test {
      public static void main(String[] args){
          //没有名字初始化类,不用将实例保存到变量中
          new Apple().eat();
      }
  }
  
  class Apple{
      public void eat(){
          System.out.println("1");
      }
  }

• main：

  package com.xd.demo02;
  ​
  public class App {
      public static void main(String[] args) {
          // new
          Outer outer = new Outer();
          //通过这个外部类来实例化内部类
          Outer.Inner inner = outer.new Inner();
          inner.in();
          inner.getID();
      }
  }