Day11

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体事物。

对象是抽象的概念的具体实例

package oop.demo02;
//学生类
public class Student {

    //属性:字段
    String name;//null
    int age;//0

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }

}

package oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //类是抽象的， 实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一的Student类的具体实例！

        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name="小明";
        xiaoming.age=18;
        xiaohong.name="小红";
        xiaohong.age=19;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);

    }
}

创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化

以及对类中构造器的调用

类中的构造也称为构造方法，是在进行创建的时候必须调用的，并且构造器有以下两个特点

1. 必须和类名字相同

2. 必须没有返回值类型，也不能写void

   package oop.demo02;
   
   public class Person {
   
       //一个类即使什么都不写，它也存在一个方法，且与类名相同。
       //显式的定义构造器
   
       String name;
   
       //实例化初始值
       //1.使用new关键字，本质是在调用构造器
       //2.用来初始化值
       public Person() {
           this.name = "单清宝";
   
       }
       //有参构造：一旦定义了有参构造，无参必须是显式定义
   public  Person(String name){
           this.name=name;
   }
       //Alt+insert  快捷键
       //构造器形成有参（无参）方法
   }
   /*
   
    public static void main(String[] args) {
   
      //new 实例化了一个对象
           Person person = new Person("shanqingbao");
           System.out.println(person.name);
    */

   package oop.demo03;
   
   public class Pet {
      public String name;
       public int age;
       public void shout(){
           System.out.println("叫了一声");
       }
   }
   /*
   
   public static void main(String[] args) {
           Pet dog = new Pet();
           dog .name="旺财";
           dog .age=3;
           dog .shout();
           System.out.println( dog .name);
           System.out.println( dog .age);
       }
   
    */

封装

该露的露，该藏得藏

高内聚，低耦合，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）

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

属性私有，get/set

package oop.demo04;
//类 private：私有
public class Student {
    /*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加了
 */
    //属性私有
    private String name;//名字
    private int age;//年龄
    private int id;//学号
    private char sex;//性别

    //提供一些可以造作这个属性的方法
    //提供一些public的get，set方法

    //get  获得这个数据
    public String getName() {
        return this.name;
    }

    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;

    }
    //alt+insert

}
/*
 public static void main(String[] args) {
        oop.demo04.Student s1 = new oop.demo04.Student();
        s1.setName("单清宝");
        System.out.println(s1.getName());


    }
 */

继承

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

extends的意思是“扩展”，子类是父类的扩展。

JAVA只有单继承，没有多继承

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

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

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

package oop.demo05;

//在java中所有类都默认继承object类
//Person   父类

public class Person {

    //public
    //default
    //protected
    //private
   private  int money=10_0000_0000;

        public void say(){
            System.out.println("说了一句话");
        }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}
/*
 public static void main(String[] args) {
        Student student = new Student();
        student.say();
        Person person = new Person();
    }
 */

object类

在java中所有类都默认继承object类

super类

注意点

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

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

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

Vs this：

代表的对象不同:

​ this: 本身调用者这个对象

​ super：代表父类对象的应用

前提

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

​ super：只有在继承条件下才可以使用

构造方法：

​ this（）：本类的构造

​ super（）：父类的构造

package oop;

import oop.demo05.Student;
import oop.demo05.Person;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        //student.test("单清宝");
        student.test01();
    }

}




package oop.demo05;
//Student  is  Person   派生类：子类
//子类继承父类，就会有父类全部的方法！
public class Student extends Person {
    //ctrl+H

    public Student() {
        //隐藏代码，调用了父类的无参构造
        super();//调用父类的构造器，必须要放在子类的第一行
        System.out.println("Student无参构造执行了");
    }

    private String name="xiaobao";

    public void print() {
        System.out.println("Student");
    }
        public void test01(){
            print();//Student
            this.print();//Student
            super.print();//Person

        }

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





package oop.demo05;

//在java中所有类都默认直接或间接继承object类
//Person   父类

public class Person {

    public Person() {
        System.out.println("Person无参构造执行了");
    }

    protected String name="shanqingbao";
public void print(){
    System.out.println("Person");
}

}

方法重写

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

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大，不能缩小 private–> public

​ public>Protect>Default>private

4. 抛出的异常：范围:可以缩小不能扩大:

   ClassNoteFoundException----> Exception

   重写：子类的方法和父类必须要一致；方法体不同!

   为什么需要重写：

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

   alt+insert: override

   package oop;
   
   import oop.demo05.A;
   import oop.demo05.B;
   
   //一个项目应该只存在一个main方法
   public class Application {
   
       //静态方法和非静态方法有很大的区别
       //静态方法：//方法的调用只和左边定义的数据类型有关
       public static void main(String[] args) {
   
   
           A a = new A();
           a.test();
           //父类的引用指向子类
           B b = new A();//非静态子类重写父类的方法
           b.test();
   
       }
   
   }
   
   
   
   package oop.demo05;
   //继承
   public class A extends B{
       //Override重写
       @Override//注解：有功能的注释
       public void test() {
           System.out.println("A=>test()");
       }
   }
   
   
   
   package oop.demo05;
   //重写都是方法是的重写，和属性无关
   public class B {
       public  void test(){
           System.out.println("B=>test()");
       }
   }