java_day08

Java基础

Java 面向对象

• 面向对象编程（Object-Oriented Programming，OOP）
• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据
• 抽象：把一类事物的公共属性提取出来 加以概括
• 三大特性
  • 封装：好比有一堆玩具 不想让他们散乱的放在外面，用一个箱子装起来 同时箱子还可以打开可以拿出玩具。把玩具放进箱子的过程就叫封装
  • 继承
  • 多态

从认识论角度考虑是现有对象后有类。对象是具体的事物；类是抽象的，是从对象的抽象；

从代码运行的角度考虑是先有类后有对象。类是对象的模板

类和对象的关系

• 类是一种抽象的数据类型，它是对某一类事物的整体描述，但不能代表某一个具体的事物
• 对象是抽象概念的具体实例
  • 张三是人的具体实例，但人不能代表张三
  • 能够体现出特点，展现出功能的是具体的实例，不是一个抽象的概念

创建和初始化对象

• 使用new关键字创建对象、

  //学生类
  public class Student {
      //属性
      String name;
      int age;
  
      //方法
      public  void study(){
          System.out.println(this.name+"在学习");
      }
  }
  
  //将学生类实例化
  //一个项目应该只存在一个main方法
  public class Application {
  
      //类是抽象的 需要实例化
      //类实例化之后会会返回一个自己的对象
      //student的对象就是一个student类的具体实例
      public static void main(String[] args) {
  
          Student stu1 = new Student();
          Student stu2 = new Student();
  
          stu1.name = "zhangsan";
          stu1.age = 23;
          System.out.println(stu1.name+" "+stu1.age);
  
          stu2.name = "lisi";
          stu2.age = 18;
          System.out.println(stu2.name+" "+stu2.age);
  
      }
  
  }
  

• new创建对象时，除了分配内存空间之外还会给创建好的对象进行默认的初始化以及对类中构造器的调用

• 类中的构造器也称为构造方法，实在进行创建对象的时候必须要调用的，并且构造器有一下两个特点

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

  /*
      构造器：
              1、与类名一直
              2、没有返回值，也不写void
         作用：
              1、new本质是再调用构造方法
              2、定义了有参构造，无参构造就需要显示定义
   */
  public class Person {
  
      String name;
  
      //类中即使什么也没有写也会存在一个与类同名的构造方法 如下所示
      //使用new关键是创建一个对象时 本质上市再调用构造器/构造方法
      //构造器或者构造方法是用来初始化值的
      public Person() {
      }
  
      //有参数的构造方法：一旦写了有参数的构造方法，默认的无参构造必须要写出来
      public Person(String name) {
          this.name = name;
      }
  }
  
  /**
   * public static void main(String[] args) {
   *         Person person = new Person();
   *         System.out.println(person.name);
   *
   *         Person person1 = new Person("zhangsan");
   *         System.out.println(person1.name);
   *
   *
   *     }
   */
  

三大特性

封装

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

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

• 属性私有，通过get/set 获取/设置属性值

  //类
  public class Student {
      //属性私有
      private String name;//名字
      private int id;//学号
      private char sex;//性别
      private int age;//年龄
  
      //提供一些可以操作私有属性的方法 get 与 set
  
      //get 获取的属性name
      public String getName(){
          return this.name;
      }
  
      //set 修改name
      public void setName(String name){
          this.name = name;
      }
  
      //alt+insert
  
  
      public int getId() {
          return id;
      }
  
      public void setId(int id) {
          this.id = id;
      }
  
      public char getSex() {
          return sex;
      }
  
      public void setSex(char sex) {
          this.sex = sex;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          if(age>120 || age<0){
              System.out.println("不要开年龄的玩笑");
          } else {
              this.age = age;
          }
  
      }
  }
  
  
  /*
  封装的作用
      1、提高程序的安全性，保护数据
      2、隐藏代码的实现细节
      3、统一接口
      4、系统可维护性增加了
  
  
  public class Application {
      public static void main(String[] args) {
          Student stu1 = new Student();
  //        System.out.println(stu1.getName());
          stu1.setName("zhangsan");
          System.out.println(stu1.getName());
  
  //        stu1.setAge(999);   //不合法年龄数据
          stu1.setAge(119);
          System.out.println(stu1.getAge());
      }
  }
  
   */
  

继承

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

• extands的意思是 拓展。子类是父类的拓展

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

• 继承是类和类之间一种关系。除此之外还有一栏、组合、聚合等

• 继承关系的两个类，一个是子类也叫派生类，一个是父类或者说基类，使用关键字extends来表示

• 子类和父类之间，从意义上来说有“is a”的关系 如 student is a person

  /*
      Java中所有的类都会直接或者间接继承Object类
      子类会继承父类的所有公共方法和属性
   */
  public class Application {
      public static void main(String[] args) {
          Student stu1 = new Student();
          System.out.println(stu1.name);
          stu1.say();
      }
  }
  
  //Person类 人
  public class Person {
  
      String name = "人类";
  
      //人类具有说话的能力
      public void say(){
          System.out.println("我能说话了");
      }
  
  }
  
  //学生类 但也是人 对于person类来时student是派生类、子类
  public class Student extends Person {
  
      //我继承了Person类，它有的功能我也有，我也可以说话
  }
  
  //Teacher类 也是人 对于person类来时teacher是派生类、子类
  public class Teacher extends Person{
      //我继承了Person类，它有的功能我也有，我也可以说话
  }
  
  

• super

  • 1、super调用父类的构造方法，必须再构造方法的第一行
  • 2、super必须只能出现在子类的方法或者构造方法中
  • 3、super和this不能同时调用构造方法

• super与this

  • 代表的对象不同

    • this 代表的是本身调用者这个对象
    • super代表父类对象的应用

  • 前提

    • this 没有继承也可以使用
    • super有继承下才可以使用

  • 构造方法

    • this() 本类的构造方法

    • super() 父类的构造方法

/*
    Java中所有的类都会直接或者间接继承Object类
    子类会继承父类的所有公共方法和属性
    父类的无参构造方法会先于子类执行
    有一种情况子类具有多个构造方法 但是父类的会在子类无参构造一定行执行，
    如果子类在无参构造中想要调用其他的有参构造 只能父类构造与子类其他构造二者选其一
 */
public class Application {
    public static void main(String[] args) {
//        Student stu1 = new Student();
//        System.out.println(stu1.name);
//        stu1.say();

        Student stu2 = new Student();
        stu2.test("application");
        stu2.test2();
    }
}

//Person类 人
public class Person {

    protected String name = "人类";
    public Person() {
        System.out.println("我是person无参构造方法");

    }

    //人类具有说话的能力
    public void say(){
        System.out.println("我能说话了");
    }

    public void print(){
        System.out.println("person");
    }

}

//学生类 但也是人 对于person类来时student是派生类、子类
public class Student extends Person {

    //我继承了Person类，它有的功能我也有，我也可以说话

    private String name = "学生";

    public Student() {
        //父类person类的无参构造会先执行相当于这里隐藏了super()
        System.out.println("我是student无参构造方法");
    }

    public void test(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }


    public void print() {
        System.out.println("student");
    }

    public void test2() {
        print();   //student
        this.print(); //student
        super.print(); //person
    }
}