Java面向对象编程03 this关键字

最新推荐文章于 2024-07-09 11:22:47 发布

小肆2019

最新推荐文章于 2024-07-09 11:22:47 发布

阅读量158

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_45861818/article/details/119306195

版权

第01阶段 Java语言基础同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

Java学习路线

16 篇文章 0 订阅

订阅专栏

this关键字

this调用本类属性

this可以算是 Java里面比较复杂的关键字，因为this的使用形式上决定了它的灵活性,在程序里面使用this可以实现以下三类结构的描述:

当前类的属性：this.属性
当前类的方法（普通方法、构造方法）：this();this.方法名称();
描述当前对象；

使用this调用当前类的属性

使用构造方法或者是setter方法都可以进行类中属性的赋值，但是在进行赋值的时候，之前采用的是如下的定义形式：

class Person { //定义一个类
    private String name ;//人员的姓名
    private int age ;//人的年龄

    public Person(String n,int a){
        name = n;
        age = a;
    }
    public void setName(String n){
        name = n;
    }
    public String setName(){
        return name;
    }
    public void setAge(int a){
        if(a>=0){
            age = a;
        }
    }
    public int setAge(){
        return age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void tell(){
        System.out.println("姓名:" + name + "、年龄:" + age);
    }
}
public class JavaDemo {//主类
    public static void main(String[] args) {
        new Person("张三", 10).tell();//进行方法的调用
    }
}

此时我们发现构造方法中的两个参数是为了给name和age赋值，发现代码中的n和a参数名称不好。
如果说现在将构造方法中的参数名称修改为name、age，则发现无法进行属性的正确设置。

class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        name = name;
        age = age;
    }
    public void tell() {
        System.out.println("姓名：" + name + "、年龄：" + age);//姓名：null、年龄：0
    }
}

在Java程序之中“{}”是作为一个结构体的边界符,那么在程序里面当进行变量（参数、属性都称为变量）使用的时候都会以“{}”作为一个查找边界，所以按照就近取用的原则，此时的构造方法并没有能够访问类中的属性，所以此时为了明确的标记出类中的属性与参数的区别，会在前面追加this关键字；

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

在你以后所编写的程序代码之中，只要是访问本类中属性的时候，请一定要加上“this”实现访问。

使用this调用方法

除了调用属性之外，this也可以实现方法的调用，但是对于方法的调用就必须考虑构造方法与普通方法：

构造方法调用( this()):使用关键字new实例化对象的时候才会调用构造方法
普通方法调用(this.方法名称()):实例化对象产生之后就可以调用普通方法。.

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.setName(name);
        setAge(age);//加与不加都表示本类方法
    }

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

    public String getName() {
        return this.name;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    public void tell() {
        System.out.println("姓名：" + name + "、年龄：" + age);
    }
}

public class JavaDemo {//主类

    public static void main(String[] args) {
        Person per = new Person("张三", 18);
        per.tell();
    }
}

除了普通的方法调用之外,还需要进行构造方法的调用，对于构造方法的调用，肯定是在构造方法里面执行。
假如在类中有三个构造方法，但是不管调用那个构造方法，都执行一行输出语句“一个新的Person类对象实例化”：
传统做法：

class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("***一个新的Person类对象实例化了。");
    }

    public Person(String name) {
        System.out.println("***一个新的Person类对象实例化了。");
        this.name = name;
    }

    public Person(String name, int age) {
        System.out.println("***一个新的Person类对象实例化了。");
        this.name = name;
        this.age = age;
    }

    //setter、getter略
    public void tell() {
        System.out.println("姓名：" + name + "、年龄：" + age);
    }
}

public class JavaDemo {//主类

    public static void main(String args[]) {
        Person per = new Person("张三", 18);
        per.tell();
    }
}

如果想要评价一个代码的好坏：
代码结构可以重用，提供的是一个中间独立的支持;
我们的目标是:没有重复

class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("***一个新的Person类对象实例化了。");
    }

    public Person(String name) {
        this();//调用无参构造
        this.name = name;
    }

    public Person(String name, int age) {
        this(name);//调用有参构造
        this.age = age;
    }


    //setter、getter略
    public void tell() {
        System.out.println("姓名：" + name + "、年龄：" + age);
    }
}

public class JavaDemo {//主类

    public static void main(String args[]) {
        Person per = new Person("张三", 18);
        per.tell();
    }
}

对于本类构造方法的互相调用需要注意以下几点重要问题:

构造方法必须在实例化新对象的时候调用，所以“this()”的语句只允许放在构造器的首行；
构造方法互相调用时请保留有程序的出口，别形成死循环

构造方法互调用案例:
现在要求定义一个描述有员工信息的程序类，该类中提供有:编号、姓名、部门、工资，
【无参构造】编号定义为1000，姓名定义为无名氏;
【单参构造】传递编号，姓名定义为“新员工”，部门定义为“未定”，工资0
【三参构造】传递编号、姓名、部门，工资为2500.00; .
【四参构造】所有的属性全部进行传递。

class Emp {
    private long empno;//员工编号
    private String ename; //员工姓名
    private String dept; //部门名称
    private double salary; //基本工资

    public Emp() {
        this.empno = 1000;
        this.ename = "无名氏";
    }

    public Emp(long empno) {
        this.empno = empno;
        this.ename = "新员工";
        this.dept = "未定";
    }

    public Emp(long empno, String ename, String dept) {
        this.empno = empno;
        this.ename = ename;
        this.dept = dept;
        this.salary = 2500.00;
    }

    public Emp(long empno, String ename, String dept, double salary) {
        this.empno = empno;
        this.ename = ename;
        this.dept = dept;
        this.salary = salary;
    }

    //getter、setter略
    public String getInfo() {
        return "雇员编号:" + this.empno +
                " 雇员姓名:" + this.ename +
                " 所在部门:" + this.dept +
                " 基本工资:" + this.salary;
    }
}

public class JavaDemo { //主类
    public static void main(String[] args) {
        Emp emp = new Emp(89989L, "张三", "财务部", 6500.00);
        System.out.println(emp.getInfo());
    }
}

此时可以发现代码有重复，所以就可以对Emp类进行简化定义。

class Emp {
    private long empno;//员工编号
    private String ename; //员工姓名
    private String dept; //部门名称
    private double salary; //基本工资

    public Emp() {
        this(1000, "无名氏", null, 0.0);
    }

    public Emp(long empno) {
        this(empno, "新员工", "未定", 0.0);
    }

    public Emp(long empno, String ename, String dept) {
        this(empno, ename, dept, 2500.0);
    }

    public Emp(long empno, String ename, String dept, double salary) {
        this.empno = empno;
        this.ename = ename;
        this.dept = dept;
        this.salary = salary;
    }

    //getter、setter略
    public String getInfo() {
        return "雇员编号:" + this.empno +
                " 雇员姓名:" + this.ename +
                " 所在部门:" + this.dept +
                " 基本工资:" + this.salary;
    }
}

public class JavaDemo { //主类
    public static void main(String[] args) {
        Emp emp = new Emp(89989L, "张三", "财务部", 6500.00);
        System.out.println(emp.getInfo());
    }
}

简单Java类

在开发与设计的过程之中，简单Java类都将作为一个重要的组成部分存在。
所谓的简单java类指的是可以描述某一类信息的程序类，例如:描述一个人、描述一本书，
并且在这个类之中并没有特别复杂的逻辑操作，只作为一种信息存储媒介存在。
对于简单Java类而言，其核心的开发结构如下:

类名称一定要有意义，可以明确的描述某一类事物;。
类之中的所有属性都必须使用private进行封装，同时封装后的属性必须要提供有setter、getter方法
类之中可以提供有无数多个构造方法，但是必须要保留有无参构造方法;
类之中不允许出现任何的输出语句，所有内容的获取必须返回;
【非必须】可以提供有一个获取对象详细信息的方法，可以暂时定为getInfo();

class Dept {//类名称可以明确描述出某类事物
    private long deptNo;
    private String deptName;
    private String location;

    public Dept() {
    }//必须提供有无参构造方法

    public Dept(long deptNo, String deptName, String location) {
        this.deptNo = deptNo;
        this.deptName = deptName;
        this.location = location;
    }

    public void setDeptNo(long deptNo) {
        this.deptNo = deptNo;
    }

    public long getDeptNo() {
        return this.deptNo;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public String getDeptName() {
        return this.deptName;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public String getLocation() {
        return this.location;
    }

    public String getInfo() {
        return "【部门信息】部门编号：" + this.deptNo +
                ",部门名称：" + this.deptName +
                ",部门位置：" + this.location;
    }
}

public class JavaDemo {
    public static void main(String arg[]) {
        Dept dept = new Dept(1234L, "财务部", "北京");
        System.out.println(dept.getInfo());
    }
}