Day01.面向对象

方法的调用

  • 静态方法

    • 关键字 static，和类一起加载。

    • 如果想在类里调用其它类的静态方法，则 类名.方法名（即可），如

    • public class Damo02 {
    public static void main(String[] args) {
        Student.say();//Student是另外的一个类
}

  • 非静态方法

    • 只有类实例化之后才存在

    • 想要在本类中调用其它类的非静态方法，则必须在本类中将其他类实例化，之后才能调用非静态方法

    • public class Damo02 {
        //实例化类 new
        //对象类型 对象名 对象值
        Student student = new Student();
        student.say1();
    }
}

    • 可以看到，如果a（）、b（）方法都为静态方法，则此时可以a可以正常调用b；但如果b为非静态方法，则调用过程中会报错。这是因为在使用b方法的时候没有实例化对象，因此b方法实际上还不存在。而a由于是静态方法，伴随着类的加载已经生成了，所以不需要实例化也能存在和被调用。image-20210227141516596image-20210227141834196

  • 形参和实参

    • 形参是为了描述方法而存在的，并非实际参在的参数。调用方法后，实际参数传递给形式参数，从而调用方法。因此实际参数和形式参数类型需要一致。

  • 值传递和引用传递

    • 简单理解，值传递，传递的是数值，而原先的变量则不会改变；
    • 引用传递，传递的是地址，形参和实参共用一个地址，所以对形参进行运算，实参也会产生变化。

  • this关键字

对象的创建与分析

  • 类是一种抽象的数据类型，是对某一类事物整体描述/定义

    • 用来描述/定义某一类具体的事物应该具备的特点和行为
    • person类、pet类、cat类等

  • 对象是抽象类的具体实例

  • 使用new关键字创建对象

    • 使用new关键字创建的时候，除了分配内存空间，还会给创建好的对象，进行默认的初始化，以及对类中构造器的调用。
    • 类i中的构造器也称为构造方法，是在进行创建对象时必须调用的。并且构造器有以下两个特点：
      • 必须和类的名字相同
      • 必须没有返回类型，也不能写void

  • 有参构造和无参构造

    • 类中默认有无参构造方法，就是在new新建对象时，不给对象赋任何初值。
    • 有参构造就是构造对象的同时，将类中的属性赋初值，这样对象中的属性就有一定的值。
    • 如果在类中声明了有参构造，那就必须显示定义无参构造。
  • public class Student {//我们定义了一个学生类，并给出类中的属性和构造方法
   //属性:字段
    String name;//null
    int age;//0

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

    };
    //有参构造
    public Student(String name,int age){
        this.name = name;//this指的就是本对象，即Student，this.name就是Student.name
        this.age = age;
    };
}

  • public class Application {//这里是应用类，我们用学生类构造了两个学生对象student和student1，其中student是无参构造，student1是有参构造

    public static void main(String[] args) {
        /*类是抽象的,我们已经定义了一个类,需要用到类中的东西,
    就需要将其实例化(除了静态方法).实例化的方法就是 new */
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例!
        Student student = new Student();
        Student student1 = new Student("cq",10);

    }

}

image-20210227184255107

如何理解类与对象的关系

  1. 类，是抽象的一类事物，在类中要定义 类的属性 以及方法。

  2. 对象，是类的实体，具有类的属性和方法。对象是通过引用来操作的：栈---》堆

  3. public class Pet{//类名为 Pet
    String name;
    int age;//name,age都是类的属性
    
    public void shout(){//shout（）是类的方法
        System.out.println("叫了一声");
    };
    
    new Student(){
        
    };//无参构造函数，用于构造尚未对属性赋值的对象，无参构造函数无须声明，但如果声明了有参构造函数，则必须对无参函数进行声明
    new Pet(String name,int age){//参数用于对属性赋值
        this.name = name;
        this.age = age;
        //this 即指构造出来的这个对象
    }//有参构造函数，用于构造对属性赋值的对象。
}

  4. public class Application {//主类
    public static void main(String[] args) {
        Pet dog = new Pet();//dog就是Pet类的一个对象，无参构造
        Pet cat = new Pet("小宝"，5)//有参构造
        dog.name = "wangcai";
        dog.age = 5;
        dog.shout();
        System.out.println(dog.age);
        System.out.println(dog.name);
    }

}

    注意：两个类必须在同一个package下才能直接调用Pet类，否则则需要加文件名

面向对象三大特性

  1. 封装

    1. 高内聚：即类的内部数据细节操作自己完成，不允许外部干涉；

    2. 低耦合：仅暴露少量的方法给外部使用；

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

    4. 属性私有，set/get

      //属性私有
private String name;
private int age;
//提供一些可以操作这个属性的方法
public getAge(){
    return age;
}
public setAge(int age){
    this.age = 3;//成员函数调用成员属性时，成员属性用“this.”
}

  2. 继承

    1. 继承是类与类的关系，其中一个作为父类（基类），另一个作为子类（派生类），子类会继承父类中的所有属性和方法，同时还能拥有其它的属性和方法。

    2. public class Student {
    String name;//null
    int age;//0
    private boolean sex;
    public void study(){
        System.out.println(this.name+"在学习");
    }
    public Student(){};
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    };
}

    3. public class goodStudent extends Student{//继承Student的所有
    private int EnglishScore;
    private int MathScore;
    private int ChineseScore;
    
    public int GetSum(){
        return this.ChineseScore+this.MathScore+this.EnglishScore;
    }
    public int GetSex(){//此处会报错，因为sex是基类的private对象，在继承时可以继承，但无法访问。
        if(this.sex) return 1;
        else return 0;
    }
    
}

    4. CTRL+H，可得树，可见在Student上仍然有Object类，实际上所有类都默认继承Object类，包括Stringimage-20210227213743416

    5. super：子类通过super来访问父类的同名属性或方法

      image-20210227231127479

  3. 多态：父类引用指向子类方法时，必须调用那些父类中存在的方法，如果子类中对该方法进行了重写，那么在运行时就会动态调用子类中的方法，这就是多态。

    1. 重写：
      1. 方法名必须相同
      2. 参数列表必须相同
      3. 修饰符范围可以扩大不能缩小
      4. 抛出的异常：范围，可以被缩小，不能被扩大
      5. 子类的方法和父类的方法体不同
    2. Father f1 = new Son();即父类引用指向子类对象
      1. f1只能使用Father类的方法,或者被Son重写的方法,Son独有的方法f1不行
      2. 多态是方法的多态
      3. 父类和子类,有联系 存在类型转换异常
      4. static private final 不能被实现
    3. 多态存在的三个必要条件
      一、要有继承；
      二、要有重写；
      三、父类引用指向子类对象。
    4. https://www.cnblogs.com/liujinhong/p/6003144.html 更详细的多态博客
posted @ 2021-02-27 23:54  deadbear  阅读(43)  评论(0)    收藏  举报