Java学习-面向对象基础（3）

最新推荐文章于 2022-06-07 10:44:27 发布
最新推荐文章于 2022-06-07 10:44:27 发布
阅读量497 收藏 1
点赞数 1
分类专栏： # Java学习笔记 文章标签： java 类 class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38124658/article/details/118915724
版权

以下笔记重点参考了如下链接：

面向对象基础

1. 方法

1.1 定义class

class Person {
    public String name;
    public int age;
}

一个class可以包含多个字段（field），字段用来描述一个类的特征。上面的Person类，我们定义了两个字段，分别为name和age;

1.2 创建实例

Person ming = new Person();

new Person()是创建Person实例。

1.3 私有变量

直接把field用public暴露给外部可能会破坏封装性，也就是外界可以直接随意赋值。

Person ming = new Person();
ming.name = "Xiao Ming";
ming.age = -99; // age设置为负数

将age设为负数，这就不符逻辑。我们可以通过private来将字段设为私有的，那么实例就无法直接修改了，也无法访问。

class Person {
    private String name;
    private int age;
}

1.4 修改与访问

虽然private变量无法直接访问，但是我们可以在类的内部通过函数方法来进行修改或者访问：

class Person {
    private String name;
    private int age;

  	// 通过方法来间接修改
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age < 0 || age > 100) {
            throw new IllegalArgumentException("invalid age value");
        }
        this.age = age;
    }
  
  	// 通过方法来间接访问
    public int getAge() {
        return this.age;
    }
    public String getName() {
        return this.name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person ming = new Person();
        ming.setName("Xiao Ming"); // 设置name
        ming.setAge(12); // 设置age
        System.out.println(ming.getName() + ", " + ming.getAge());
    }
}
  • 请注意上述类的方法是public的，那么对应也有private的方法；此时也无法直接访问方法。

1.4 this变量

在方法内部，可以使用一个隐含的变量this，它始终指向当前实例。

class Person {
    private String name;

    public String getName() {
        return name; // 相当于this.name
    }
}

但是，如果有局部变量和字段重名，那么局部变量优先级更高，就必须加上this。

class Person {
    private String name;

    public void setName(String name) {
        this.name = name; // 前面的this不可少，少了就变成局部变量name了
    }
}

1.5 可变参数

可变参数用类型...定义，可变参数相当于数组类型：

class Group {
    private String[] names;

    public void setNames(String... names) {
        this.names = names;
    }
}

上面的setNames()就定义了一个可变参数。调用时，可以这么写：

Group g = new Group();
g.setNames("Xiao Ming", "Xiao Hong", "Xiao Jun"); // 传入3个String
g.setNames("Xiao Ming", "Xiao Hong"); // 传入2个String
g.setNames("Xiao Ming"); // 传入1个String
g.setNames(); // 传入0个String

当然，可以把可变参数改写为String[]类型：

class Group {    private String[] names;    public void setNames(String[] names) {        this.names = names;    }}

但是，调用方需要自己先构造String[]，比较麻烦。例如：

Group g = new Group();g.setNames(new String[] {"Xiao Ming", "Xiao Hong", "Xiao Jun"}); // 传入1个String[]

1.6 参数绑定

  • 基本类型参数的传递，是调用方值的复制。双方各自的后续修改，互不影响。
  • 引用类型参数的传递，调用方的变量，和接收方的参数变量，指向的是同一个对象。比如传入数组，但是传入string类型的字符却不会。
public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        String[] fullname = new String[] { "Homer", "Simpson" };
        p.setName(fullname); // 传入fullname数组
        System.out.println(p.getName()); // "Homer Simpson"
        fullname[0] = "Bart"; 
        System.out.println(p.getName());
    }
}

class Person {
    private String[] name;

    public String getName() {
        return this.name[0] + " " + this.name[1];
    }

    public void setName(String[] name) {
        this.name = name;
    }
}

/*
输出：
Homer Simpson
Bart Simpson
*/

2. 构造方法

2.1 默认构造方法

我们可以通过构造方法，在创建实例的时候，就初始化实例。

public class Main {
    public static void main(String[] args) {
        Person p = new Person("Xiao Ming", 15);
        System.out.println(p.getName());
        System.out.println(p.getAge());
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}

调用构造方法，必须用new操作符。如果一个类没有定义构造方法，编译器会自动为我们生成一个默认构造方法，它没有参数，也没有执行语句，类似于：

class Person {
    public Person() {
    }
}
  • 如果我们自定义了一个构造方法，那么，编译器就不再自动创建默认构造方法。
  • 没有在构造方法中初始化字段时，引用类型的字段默认是null，数值类型的字段用默认值，int类型默认值是0，布尔类型默认值是false。

2.2 多构造方法

可以定义多个构造方法，在通过new操作符调用的时候，编译器通过构造方法的参数数量、位置和类型自动区分：

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this.name = name;
        this.age = 12;
    }

    public Person() {
    }
}

如果调用new Person("Xiao Ming", 20);，会自动匹配到构造方法public Person(String, int)。

一个构造方法可以调用其他构造方法，这样做的目的是便于代码复用。调用其他构造方法的语法是this(…)：

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this(name, 18); // 调用另一个构造方法Person(String, int)
    }

    public Person() {
        this("Unnamed"); // 调用另一个构造方法Person(String)
    }
}

3. 方法重载

在一个类中，我们可以定义多个方法，它们的功能都是类似的，只有参数有所不同。例如：

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}

这种方法名相同，但各自的参数不同，称为方法重载（Overload）。注意：方法重载的返回值类型通常都是相同的。

4. 继承

4.1 extends

java使用extends关键字来实现继承：

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;

    public int getScore() { … }
    public void setScore(int score) { … }
}
  • 子类自动获得了父类的所有字段，严禁定义与父类重名的字段。
  • 在OOP的术语中，我们把Person称为超类（super class），父类（parent class），基类（base class），把Student称为子类（subclass），扩展类（extended class）。
  • 任何类，除了Object，都会继承自某个类。类Person看上去没有继承，实际继承的是object。

4.2 protected

  • 继承有个特点，就是子类无法访问父类的private字段或者private方法。

  • 为了让子类可以访问父类的字段，我们需要把private改为protected。用protected修饰的字段可以被子类访问：

class Person {
    protected String name;
    protected int age;
}

class Student extends Person {
    public String hello() {
        return "Hello, " + name; // OK!
    }
}

因此，protected关键字可以把字段和方法的访问权限控制在继承树内部，一个protected字段和方法可以被其子类，以及子类的子类所访问

4.3 super

super关键字表示父类（超类）。子类引用父类的字段时，可以用super.fieldName。例如：

class Student extends Person {
    public String hello() {
        return "Hello, " + super.name;
    }
}

实际上，这里使用super.name，或者this.name，或者name，效果都是一样的。编译器会自动定位到父类的name字段。但是，在某些时候，就必须使用super：

  • 任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句super();

  • 如果父类重写了构造函数，子类的构造函数第一行就要用super()调用父类的构造函数：

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(name, age); // 调用父类的构造方法Person(String, int)
        this.score = score;
    }
}

4.4 final

正常情况下，只要某个class没有final修饰符，那么任何类都可以从该class继承。

从Java 15开始，允许使用sealed修饰class，并通过permits明确写出能够从该class继承的子类名称。

例如，定义一个Shape类：

public sealed class Shape permits Rect, Circle, Triangle {
    ...
}

上述Shape类就是一个sealed类，它只允许指定的3个类继承它。

4.5 向上转型

如果Student是从Person继承下来的，那么，一个引用类型为Person的变量，能否指向Student类型的实例？

Person p = new Student(); // ???

测试一下就可以发现，这种指向是允许的！

这是因为Student继承自Person，因此，它拥有Person的全部功能。这种把一个子类类型安全地变为父类类型的赋值，被称为向上转型（upcasting）。

向上转型实际上是把一个子类型安全地变为更加抽象的父类型：

Student s = new Student();
Person p = s; // upcasting, ok
Object o1 = p; // upcasting, ok
Object o2 = s; // upcasting, ok

注意到继承树是Student > Person > Object，所以，可以把Student类型转型为Person，或者更高层次的Object。

4.5 向下转型

和向上转型相反，如果把一个父类类型强制转型为子类类型，就是向下转型（downcasting）。例如：

Person p1 = new Student(); // upcasting, ok
Person p2 = new Person();
Student s1 = (Student) p1; // ok
Student s2 = (Student) p2; // runtime error! ClassCastException!

向下转型很可能会失败。失败的时候，Java虚拟机会报ClassCastException。

为了避免向下转型出错，Java提供了instanceof操作符，可以先判断一个实例究竟是不是某种类型：

Person p = new Person();
System.out.println(p instanceof Person); // true
System.out.println(p instanceof Student); // false

Student s = new Student();
System.out.println(s instanceof Person); // true
System.out.println(s instanceof Student); // true

Student n = null;
System.out.println(n instanceof Student); // false

instanceof实际上判断一个变量所指向的实例是否是指定类型，或者这个类型的子类。如果一个引用变量为null，那么对任何instanceof的判断都为false。

利用instanceof，在向下转型前可以先判断：

Person p = new Student();
if (p instanceof Student) {
    // 只有判断成功才会向下转型:
    Student s = (Student) p; // 一定会成功
}

5. 多态

5.1 覆写

在继承关系中，子类如果定义了一个与父类方法签名完全相同的方法，被称为覆写（Override）。

例如，在Person类中，我们定义了run()方法：

class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

在子类Student中，覆写这个run()方法：

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

Override和Overload不同的是，如果方法签名不同，就是Overload，Overload方法是一个新方法；如果方法签名相同，并且返回值也相同，就是Override。

  • 方法声明的两个组件构成了方法签名 - 方法的名称和参数类型。

  • 方法名相同，方法参数相同，但方法返回值不同，也是不同的方法。

5.2 Override

加上@Override可以让编译器帮助检查是否进行了正确的覆写。希望进行覆写，但是不小心写错了方法签名，编译器会报错。但是@Override不是必需的。

在上一节中，我们已经知道，引用变量的声明类型可能与其实际类型不符，例如：

Person p = new Student();

现在，我们考虑一种情况，如果子类覆写了父类的方法：

// override

5.3 多态

如果，一个实际类型为Student，引用类型为Person的变量，调用其run()方法，调用的是Person还是Student的run()方法？实际上调用的方法是Student的run()方法。

结论：Java的实例方法调用是基于运行时的实际类型的动态调用，而非变量的声明类型。这个非常重要的特性在面向对象编程中称之为多态。

例：

public class Main {
    public static void main(String[] args) {
        // 给一个有普通收入、工资收入和享受国务院特殊津贴的小伙伴算税:
        Income[] incomes = new Income[] {
            new Income(3000),
            new Salary(7500),
            new StateCouncilSpecialAllowance(15000)
        };
        System.out.println(totalTax(incomes));
    }

    public static double totalTax(Income... incomes) {
        double total = 0;
        for (Income income: incomes) {
            total = total + income.getTax();
        }
        return total;
    }
}

//一般税率
class Income {
    protected double income;

    public Income(double income) {
        this.income = income;
    }

    public double getTax() {
        return income * 0.1; // 税率10%
    }
}

//超出部分交税
class Salary extends Income {
    public Salary(double income) {
        super(income);
    }

    @Override
    public double getTax() {
        if (income <= 5000) {
            return 0;
        }
        return (income - 5000) * 0.2;
    }
}

//不用交税
class StateCouncilSpecialAllowance extends Income {
    public StateCouncilSpecialAllowance(double income) {
        super(income);
    }

    @Override
    public double getTax() {
        return 0;
    }
}

观察totalTax()方法：利用多态，totalTax()方法只需要和Income打交道，它完全不需要知道Salary和StateCouncilSpecialAllowance的存在，就可以正确计算出总的税。

5.4 覆写Object方法

因为所有的class最终都继承自Object，而Object定义了几个重要的方法：

  • toString()：把instance输出为String；
  • equals()：判断两个instance是否逻辑相等；
  • hashCode()：计算一个instance的哈希值。

在必要的情况下，我们可以覆写Object的这几个方法。

5.5 调用super

在子类的覆写方法中，如果要调用父类的被覆写的方法，可以通过super来调用。例如：

class Person {
    protected String name;
    public String hello() {
        return "Hello, " + name;
    }
}

Student extends Person {
    @Override
    public String hello() {
        // 调用父类的hello()方法:
        return super.hello() + "!";
    }
}

5.6 final

继承可以允许子类覆写父类的方法。如果一个父类不允许子类对它的某个方法进行覆写，可以把该方法标记为final。用final修饰的方法不能被Override：

class Person {
    protected String name;
    public final String hello() {
        return "Hello, " + name;
    }
}

Student extends Person {
    // compile error: 不允许覆写
    @Override
    public String hello() {
    }
}

如果一个类不希望任何其他类继承自它，那么可以把这个类本身标记为final。用final修饰的类不能被继承：

final class Person {
    protected String name;
}

// compile error: 不允许继承自Person
Student extends Person {
}

对于一个类的实例字段，同样可以用final修饰。用final修饰的字段在初始化后不能被修改。例如：

class Person {
    public final String name = "Unamed";
}

对final字段重新赋值会报错：

Person p = new Person();
p.name = "New Name"; // compile error!

可以在构造方法中初始化final字段：

class Person {
    public final String name;
    public Person(String name) {
        this.name = name;
    }
}

这种方法更为常用，因为可以保证实例一旦创建，其final字段就不可修改。

xLyons
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java实验3_java 实验3 继承+多态
weixin_39864489的博客
02-12 1229
实验3 继承与多态**类可以实现多个接口 但只有单继承！**1、继承1)、继承语法class子类名extends父类{}2)、构造函数(通过source即可得到)注意： 当子类实例化，首先调用父类构造函数，其次调用子类本身构造函数3)、函数重载:简单来说 相同函数名 参数需求不同 在调用时自动寻找匹配的函数4)、覆盖问题override子类重写了一个从父类继承过来的函数与属性---当使用时就直接...
Drools规则引擎-memberOf操作
程序新视界
07-15 2961
场景 规则引擎技术讨论2群（715840230）有同学提出疑问，memberOf的使用过程中如果，memberOf之后的参数不是集合也不是数组，而是格式如“1,2,3,4”的字符串，那么Drools是否会讲其转换成数组？ 其实很显然，Drools规则引擎不会这么做，它也并不知道你定义的字符串的格式及分隔符是什么，不会像SpringMVC那样约定好以json格式进行解析。 今天这批文章就带大家了解一...
干货，一文彻底搞懂 Java 的 Optional
热门推荐
沉默王二
03-10 3万+
史上最好的 Optional 指南，没有之一
java练习题（包含读程序选择题）（附答案）
weixin_45797533的博客
06-07 5336
一些关于java读程序的练习题
详解 Java 的对象与类（二）
lfm1010123的博客
05-09 939
this 关键字、封装、包的含义、继承
JAVA-面向对象基础-字符串-集合
09-27
观看黑马程序员Java零基础视频教学，从60P方法开始总结的知识集合，请使用Xmind打开，如果需要学习请配合视频打开：https://www.bilibili.com/video/BV17F411T7Ao
JAVA面向对象基础学习资料
07-09
JAVA面向对象的基础学习资料，包括了以下学习内容和代码注释： 01_成员变量和局部变量的区别 02_形式参数是类名的问题 03_匿名对象 04_封装和private关键字 05_this关键字 06_构造方法 07_成员方法 08_创建对象做了...
java-面向对象的英雄类
12-20
在Java编程语言中，面向对象（Object-Oriented ...通过解决这样的测试题，开发者不仅能掌握面向对象编程的基础，还能锻炼解决问题的能力，为以后的Java项目开发打下坚实的基础。希望所有学习者都能从中受益，不断进步。
Java基础-面向对象源程序
11-04
"Java基础-面向对象源程序"这个资料包，显然包含了关于Java语言面向对象特性的实例源代码，是初学者巩固和提升Java基础的绝佳资源。下面我们将深入探讨面向对象的三大核心概念：封装、继承和多态，并结合Java语言的...
Java零基础-面向对象封装性.md
最新发布
08-10
学习面向对象编程中的封装性概念和原则。 理解如何定义类、私有属性和公有方法，并在类内部进行属性的设置和获取。 掌握如何通过公有方法在外部访问类的属性和方法，实现对对象的封装和保护。 阅读建议： 建议读者...
关于Action的参数
Shao_mou_ren的博客
05-27 2117
ASP.Net MVC会自动对参数做类型转换； 对于boolean类型的参数（或者Model的属性），如果使用checkbox，则value必须是"true"，否则值永远是false。对于double、int等类型会自动进行类型转换。 1 一个Controller可以有多个方法，这些方法叫Action。通过“Controller名字/方法名”访问的时候就会执行对应的方法。 2 Action的三种类型的参数：普通参数、Model类、FormCollection。 普通参数：Index(strin
c++ default override delete关键字
bitcarmanlee的博客
05-11 1286
0.前言 c++11中，新增加了许多关键字与新用法。下面我们针对c++11里面的新特性，来看看这些关键字的用法。 1.default 在阅读项目源码时，看到许多default关键字，我们先通过一个例子来说明default的用法。 class Person { private: string name; public: Person(string _name) : name(_name) {} }; int main(int argc, char const
JAVA作业2&实验2 类与对象
super_iron_man的博客
01-03 3260
6-1 Person类 (20分) 构造Person类。包括姓名(name)，性别(sex)和年龄(age)。提供所有属性的set和get函数，提供print函数打印其信息 输入描述： 姓名(name)，性别(sex)和年龄(age) 输出描述： 用户信息 裁判测试程序样例： import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner scan = new
编写Java程序，建立一个人类(Person)和学生类(Student)
qq_44758926的博客
07-02 1万+
编写Java程序，建立一个人类(Person)和学生类(Student) 要求如下：  Person中包含4个私有的数据成员name, addr, sex, age， 分别为字符串型，字符串型，字符型，整形，表示姓名、地址、性别和年龄。用一个4参构造方法、一个2参构造方法、一个无参构造方法、一个输出方法显示4种属性；  Student类继承Person类，并增加成员math, english存放数学和英语成绩，一个6参构造方法、一个2参构造方法、一个无参构造方法和重写输出方法用于显示6种属性。 pack
java学习面向对象之父子构造函数初始化
weixin_30437337的博客
09-25 85
在之前讲到java面向对象继承的时候，我们只讲到了两个比较重要的知识点，一个是父子类当中有同名的成员变量，这个时候，我们引入了super这个关键字来区分这两个同名成员变量，除此之外，我们还讲到了父子同名函数的覆盖，这父子同名函数必须是参数类型、个数相同，返回值也相同才可以，同时子类要覆盖后的成员方法的访问权限要大于等于父类当中的同名函数权限。 那么还有一个地方我们没有讲到，那就是父子当中的构造函...
public void setName(String name)
u012402926的专栏
07-11 6695
public void setName(String name) { 　　this.name = name; 　　} 　　public int getAge() { 　　return age; 　　} 　　public void setAge(int age) { 　　this.age = age; 　　} 　　public void cry(){ 　　System.out.p
public static void main(String[] args){} 关于Java main()方法
开着奥迪卖小猪
06-30 1万+
是Java程序的入口方法，JVM在运行程序时，会首先查找main()方法。 　　public是权限修饰符，表明任何类或对象都可以访问这个方法； 　　static表明main()方法是一个静态方法，即方法中的代码时存储在静态区的，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过 类名.main() 直接访问； 　　void表明方法没有返回值； 　　main是JVM识别的特殊
引用类型参数的传递
Hugo_Knight的博客
03-26 1022
引用类型参数的传递 ECMAScript中所有函数的参数都是按值传递的。也就是说，把函数外部的值复制给函数内部的参数，就和把值从一个变量复制到另一个变量一样。基本类型值的传递同基本类型变量的复制一样，而引用类型值的传递，则如同引用类型变量的复制一样。 在向参数传递基本类型的值时被传递的值会被复制给一个局部变量（即命名参数，或者用ECMAScript的概念来说，就是arguments对象中的一个元素...
引用类型参数绑定 | 针对廖雪峰老师的两个例子的个人理解（是我太笨，对知识比较慢热）
北溟南风起
02-22 789
引用类型参数绑定 | 针对廖雪峰老师的两个例子的个人理解。廖雪峰的话，耐人寻味！
完整版 Java编程基础入门教程 Java语言程序设计 第3章_面向对象程序设计基础（共16页）.ppt
12-18
第3章"面向对象程序设计基础"是学习Java的重要组成部分，主要探讨了继承这一关键特性。 继承在面向对象编程中扮演着至关重要的角色，它允许一个类（子类）继承另一个类（父类）的属性和方法。这具有显著的优点，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值