华清远见重庆中心-面向对象阶段技术总结

LiuTakeOff

已于 2022-11-23 00:01:22 修改

阅读量399

点赞数

文章标签： java 开发语言

于 2022-11-23 00:00:30 首次发布

本文链接：https://blog.csdn.net/LiuTakeOff/article/details/127983918

版权

调用方法

1.通过类名调用

被static修饰的静态方法被调用时可以直接通过类名调用。

package com.hqyj.text3;
public  class Aaa{
    public static void main (String[] args) {
        //Math类是一个数学工具类,类中的方法都是静态方法
        //调用时直接通过Math类名访问
        int num= Math.abs(-5);
        System.out.println(num);
    }
}

2.通过对象调用

类名对象名 = new 类名 ();

package com.hqyj.text3;

import java.util.Random;

public  class Aaa{
    public static void main (String[] args) {
        //创建一个Random类的对象rd
        Random rd = new Random();
        //生成[0,10)范围内的随机数
        int num = rd.nextInt(10);
        System.out.println(num);
    }
}

面向过程和面向对象的编程思想

面向过程编程思想Procedure Oriented Programming(pop)是一种基本的编程思想，是将一件事按流程逐步实现。这种思想强调事情完成的过程，分析步骤写出相应的代码。比如c语言就是一门标志性的面向过程编程语言。亲力亲为，侧重于分析完成事情的过程。

面向对象编程思想Object Oriented Programming(oop)是当主流的编程思想，是创建解决问题的对象，赋予对象对应的行为和特征，让这些对象互相配合(调用对象的方法)完成。这种思想致力于将计算机中的世界，描述的和现实中一致的思想。所有事情交给相应的对象完成，侧重于如何创建解决问题的对象。

成员变量,局部变量,静态常量

成员变量是定义在类中的变量，称为成员变量，拥有默认值。

public  class Aaa{
    String num="dsad";//成员变量,默认值为null
    void la(){
        System.out.println(num);
    }
}

局部变量是定义在方法中的变量，称为局部变量。没有默认值，赋值后才能使用。

public  class Aaa{
    public static void main(String[] args) {
        String num="asd";//局部变量,没有默认值,定义之后才能用
        System.out.println(num);
    }
}

静态常量是特殊的成员变量，用final static修饰。它有默认值。通过类名访问。

public  class Aaa{
    public static final String COUNTRY="中国";//静态常量,不能更改,字母大写
    public static void main(String[] args) {
        System.out.println(COUNTRY);
    }
}

构造方法

构造方法是一种特殊的方法。方法名和类名一致，没有返回值部分。

public  class Aaa{
    // 方法名和类名一致
    // 在使用new关键字创建对象时，调用对应的构造方法。
    public Aaa(){
        System.out.println("构造方法");
    }
}

面对对象的三大特性

封装

是使用private关键字对属性进行修饰。再对外提供一组公开的get/set方法用于对该属性读取或赋值。可以防止除自身类之外的地方对该属性就行访问。这样做可以保护关键属性，隐藏类内部的实现细节。

public  class Aaa{
    private String num;

    public Aaa(String num) {
        this.num = num;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }
}

继承

是通过extends关键字类A（子类）继承类B（父类）。继承后，子类可以访问父类中非私有(没有被private修饰的内容)的属性和方法。

class B{
    public void b(){
        System.out.println("父类");
    }
}
class A extends B{
    public void a() {
        System.out.println("子类");
    }
}

方法重写（override）是当子类继承父类后，可以对父类中非私有的方法进行扩展或覆盖，这个过程称为方法重写。

class B{
    public void b(){
        System.out.println("父类");
    }
}
class A extends B{
    //重写b方法
    //方法名、参数列表、返回值必须和父类一致
    //访问权限不能比父类更严格
    //不能抛出比父类更大的异常
    public void b() {
        System.out.println("子类");
    }
}

方法重载（overlord）是在一个类中，如果多个方法的方法名相同，参数列表不同时，这些方法称为重载的方法。

class B{
    public void b(){
        System.out.println("无参");
    }
    public void b(int i){
        System.out.println("有参"+i);
    }
}
class A {
    public static void main(String[] args) {
        //重载b方法
        //方法名必须相同,参数列表必须不同,无返回值
        B b=new B();
        b.b();
        b.b(10);
    }
}

this()和super()用法1：“this.属性”或“this.方法”或“super.属性”或“super.方法” 此时的this或super表示“当前类”或"父类对象"。用法2："this([参数])或super([参数])"此时的this([参数])或super([参数])表示当前类或当前类的父类的某个构造方法。

注意:如果父类中有无参数的构造方法，在子类的构造方法中，可以不写super() ，系统会自动调用。如果父类中有带参数的构造方法，没有无参数的构造方法，在子类的构造方法中，必须要写super() ，并且赋予适当的参数。

多态

就是子类的对象指向父类的引用(子类对象使用父类变量接收，即向上转型)。

class B {
}

class A extends B {

}

class Main1 {
    public static void main(String[] args) {
        A a = new A();
        //这就是多态的体现
        //子类的对象，可以使用父类的变量保存
        //在继承关系中
        //子类需要重写父类中的方法
        //父类的引用指向子类的对象
        B b=new B();
    }
}

当某个方法的参数为父类变量时，可以传递一个子类对象。这样就能在传递不同子类对象时，执行不同的方法。

Object类

Object类是所有类的父类。任何类都间接地继承了该类，但没有明确地使用extends 体现出来。所有类都可以访问Object 类中的方法，或对其进行重写。

toString() 就是 Object 类中的一个方法，在输出对象时自动调用。默认输出的是 " 类名 @ 十六进制哈希码" ，通常在自定义类中，重写 toString() ，从而输出该类中的属性。

equals() 也是 Object 类中的一个方法，用于比较两个对象是否相同。默认使用 == 比较，即比较内存地址，通常需要重写该方法，自定义判断两个对象是否相同时所需的参数。

    @Override
    public String toString() {
        return "Role{" +
                "name='" + name + '\'' +
                ", camp='" + camp + '\'' +
                ", weapon='" + weapon + '\'' +
                ", harm=" + harm +
                ", skill='" + skill + '\'' +
                ", blood=" + blood +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Role role = (Role) o;
        return harm == role.harm && Objects.equals(name, role.name) && Objects.equals(camp, role.camp) && Objects.equals(weapon, role.weapon) && Objects.equals(skill, role.skill);
    }