方法＆封装

于 2020-12-15 15:28:17 发布
阅读量194 收藏
点赞数
分类专栏： JavaSE 拉勾教育 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Guai_Ka/article/details/111190748
版权

前言

文章内容输出来源：拉勾教育JAVA就业训练营
总目录跳转链接：总目录
如有侵权请联系本人
邮箱:xiaogueika@tom.com

文章目录

一、构造方法（重中之重）

构造方法的基本概念

class 类名 {
	类名(形参列表) {
		构造方法体;
	}
}
class Person {
	Person() { //- Person类中的构造方法
	}
}
  • 构造方法名与类名完全相同并且没有返回值类型，连void都不许有。

默认构造方法

  • 当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造构造方法，叫做默认/缺省构造方法，如：Person(){}
  • 若类中出现了构造方法，则编译器不再提供任何形式的构造方法。

构造方法的作用

使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作。

package cn.cyh.demo1_2.d2;

/**
 * 编程实现Person类的定义
 * @author cyh
 * @create 2020/12/15 9:05
 */
public class Person {
    String name;    //用于描述姓名的成员变量
    int age;        //用于描述年龄的成员变量
    //自定义构造方法
    Person(String name,int age){
        //System.out.println("我就是自定义的构造方法!");
        this.name = name;
        this.age = age;
    }
    //自定义成员方法实现所有特征的打印
    void show(){
        System.out.println("我是" + name + ",今年" + age + "岁");
    }
    public static void main(String[] args) {
        //1.声明一个Person类型的引用指向Person类型的对象
        //当类中没有提供构造方法时，则下面调用默认构造方法，若类中提供构造方法后，则下面调用类中提供的版本
        Person p1 = new Person("张飞",30);
        //打印特征
        p1.show();
        System.out.println("----------------------            ");
        Person p2 = new Person("关羽",35);
        p2.show();
    }
}

在这里插入图片描述

1、案例题目：

编程实现Point类的定义并向Point类添加构造方法
Point() 默认创建原点对象
Point(int i, int j) 根据参数创建点对象

package cn.cyh.demo1_2.d2;

/**
 * @author cyh
 * @create 2020/12/15 9:31
 */
public class Point {
    int x;//用于描述横坐标的成员变量
    int y;//用描述纵坐标的成员变量
    //自定义无参构造方法
    Point(){}
    Point(int x, int y){
        this.x = x;
        this.y = y;
    }

    //自定义成员方法实现成员变量数值的打印
    void show(){
        System.out.println("横坐标是:" + x +",纵坐标是:" + y);
    }

    public static void main(String[] args) {
        //1.使用无参方式构造对象并打印特征
        Point p1 = new Point();
        p1.show();
        //2.使用有参方式构造对象并打印特征
        Point p2 = new Point(3,5);
        p2.show();
    }
}

二、方法重载（重点）

方法重载的概念

若方法名称相同，参数列表不同，这样的方法之间构成重载关系(Overload)。

重载的体现形式

  • 方法重载的主要形式体现在：参数的个数不同、参数的类型不同、参数的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好相同。
  • 判断方法能否构成重载的核心：调用方法时能否加以区分。
package cn.cyh.demo1_2.d2;

/**
 * 编程实现方法重载主要形式的测试
 * @author cyh
 * @create 2020/12/15 9:36
 */
public class OverloadTest {
    //自定义成员方法
    void show(){
        System.out.println("show()");
    }
    void show(int i){   //体现在方法参数的个数不同
        System.out.println("show(int)");
    }
    void show(int i, double d){   //体现在方法参数的个数不同
        System.out.println("show(int,double)");
    }
    void show(int i, int j){    //体现在方法参数的类型不同
        System.out.println("show(int,int)");
    }
    void show(double d, int i){   //体现在方法参数的顺序不同
        System.out.println("show(double,int)");
    }
//    void show(double a, int b){   //error 与参数变量名无关
//        System.out.println("show(double,int)");
//    }
//    int show(double a, int b){   //error 与返回值类型无关
//        System.out.println("show(double,int)");
//    }
    public static void main(String[] args) {
        //1.声明overloadrest类型的引用指向该类型的对象
        OverloadTest ot = new OverloadTest();
        //2.调用show方法
        ot.show();
        ot.show(1);
        ot.show(1,3.14);
        ot.show(1,1);
        ot.show(3.14,66);
    }
}

2、案例题目：

编程实现为Point类添加重载的成员方法：
up() – 实现纵坐标减1的功能。
up(int dy) – 实现纵坐标减去参数指定数值的功能。
测试重载方法的调用规则

//------------------类内、main方法外---------------------------
    //自定义成员方法实现纵坐标减1的行为
    void up(){
        y--;
    }
    //自定义成员方法实现纵坐标减去参数指定数值的行为
    void up(int i){
        y -= i;
    }
//------------------main方法内---------------------------
        p2.up();
        p2.show();
        p2.up(2);
        p2.show();

重载的实际意义

  • 方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本，来实现各种不同的功能。
  • 如：java.io.PrintStream类中的println方法。

三、this关键字

this的基本概念

  • 若在构造方法中出现了this关键字，则代表当前正在构造的对象。
  • 若在成员方法中出现了this关键字，则代表当前正在调用的对象。
  • this关键字本质上就是当前类类型的引用变量。
package cn.cyh.demo1_2.d2;

/**
 * 编程实现this关键字的使用
 * @author cyh
 * @create 2020/12/15 10:13
 */
public class ThisTest {
    //自定义构造方法
    ThisTest(){
        System.out.println("构造方法中: this = " + this);
    }
    //自定义成员方法
    void show(){
        System.out.println("成员方法: this = " + this);
    }
    public static void main(String[] args) {
        //1.声明ThisTest类型的引用指向该类型的对象
        ThisTest tt = new ThisTest();
        //2.调用show方法
        tt.show();
        System.out.println("mian方法中: tt = " + tt);
    }
}
/**
* 构造方法中: this = cn.cyh.demo1_2.d2.ThisTest@1b6d3586
* mian方法中: tt = cn.cyh.demo1_2.d2.ThisTest@1b6d3586
* 成员方法: this = cn.cyh.demo1_2.d2.ThisTest@1b6d3586
*/

工作原理

在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之不同。

使用方式

  • 当局部变量名与成员变量名相同时，在方法体中会优先使用局部变量(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前缀，明确要求该变量是成员变量（重中之重）。
  • this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以作为方法的返回值（重点）。
  • 在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法（了解）。

注意事项

  • 引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象。
  • 当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生NullPointerException 异常（空指针异常）。

四、方法递归调用（难点）

案例题目

编程实现参数n的阶乘并返回，所谓阶乘就是从1累乘到n的结果。

package cn.cyh.demo1_2.d2;
/**
 * 编程实现累乘积的计算并打印(递归)
 * @author cyh
 * @create 2020/12/15 11:43
 */
public class JieChengTest {
    //自定义成员方法实现将参数n的阶乘计算出来并返回
    // 1！=1;  2！=1*2;  3！=1*2*3; …… n! = 1*2*3……*n
    int show(int n){
//		递推的方式
//        int num = 1;
//        for (int i = 1; i <= n; i++) {
//            num *= i;
//        }
//        return num;
        //当n的数值为1时，则阶乘的结果就是1
        //递归的方式
        if(n == 1){
            return 1;
        }
        //否则阶乘的结果就是n*（n-1）
        return n * show(n - 1);
    }

    public static void main(String[] args) {
        //1.声明JiechengTest类型的引用指向该类型的对象
        JieChengTest jct =new JieChengTest();
        //2.调用方法进行计算并打印
        int res = jct.show(5);
        System.out.println("最终的计算结果是：" + res);
    }

}

递归的基本概念

递归本质就是指在方法体的内部直接或间接调用当前方法自身的形式。

注意事项

  • 使用递归必须有递归的规律以及退出条件。
  • 使用递归必须使得问题简单化而不是复杂化。
  • 若递归影响到程序的执行性能，则使用递推取代之。

案例题目

编程实现费式数列中第n项的数值并返回。
费式数列： 1 1 2 3 5 8 13 21 ……

package cn.cyh.demo1_2.d2;

/**
 * 编程实现费氏数列的计算并打印
 * @author cyh
 * @create 2020/12/15 14:12
 */
public class FeeTest {
    //自定义成员方法实现费氏数列中第n项数值的计算并返回，n由参数指定
    //1 1 2 3 5 8 13 21 ……
    int show(int n){
//1.使用递归的方式进行计算
//        if(n == 1 || n == 2){
//            return 1;
//        }
//        return show(n - 1) + show(n - 2);
        int ia = 1;
        int ib = 1;
        for (int i = 3; i <= n; i++) {
            int ic = ia + ib;
            ia = ib;
            ib = ic;
        }
        return ib;
    }
    public static void main(String[] args) {
        //1.声明Feerest类型的引用指向该类型的对象
        FeeTest fee = new FeeTest();
        //2.调用方法计算并打印
       // int res = fee.show(55);
        //System.out.println("计算的结果是: " + res);
    }
}

五、封装（重中之重）

封装的概念

  • 通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符。
  • 为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装。

封装的实现流程

  • 私有化成员变量，使用private关键字修饰。
  • 提供公有的get和set方法，并在方法体中进行合理值的判断。
  • 在构造方法中调用set方法进行合理值的判断。

访问控制修饰符继承有讲

同一个类同一个包不同包的子类不同包的非子类
private√
default√√
protect√√√
public√√√√
  • public：
    Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。
  • private:
    Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
  • protect:
    介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
  • default：
    即不加任何访问修饰符，通常称为“默认访问模式“。该模式下，只允许在同一个包中进行访问。

案例题目

提示用户输入班级的学生人数以及每个学生的信息，学生的信息有：学 号、姓名，最后分别打印出来。
提示：Student[] arr = new Student[num];

Student类：

package cn.cyh.demo1_2.d2;

/**
 * 编程实现student类的封装
 * @author cyh
 * @create 2020/12/15 14:44
 */
public class Student {
    //1.私有化成员变量，使用private关键字修饰
    //private关键字修饰表示私有的含义，也就是该成员变量只能在当前类的内部使用
    private int id;         //用于描述学号的成员变量
    private String name;    //用于描述姓名的成员变量
    public Student(){}

    public Student(int id, String name) {
        setId(id);
        setName(name);
    }
    //提供公有的get和set方法，并在方法体中进行合理值的判断
    //使用public关键字修饰表示公有的含义，也就是该方法可以在任意位置使用
    public int getId() {
        return id;
    }
    public void setId(int id) {
        if(id > 0){
            this.id = id;
        } else {
            System.out.println(name + "的学号赋值不合理");
        }

    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //自定义成员方法实现特征的打印
    //什么修饰符都没有叫做默认的访问权限，级别介于private和public之间
    void show(){
        System.out.println("我是:" + name + ",我的学号是:" + id);
    }
}

Student测试类：

package cn.cyh.demo1_2.d2;

import java.util.Scanner;
/**
 * 编程实现学生信息的录入和打印
 * @author Administrator
 * @create 2020/12/15 15:14
 */
public class StudentTest2 {
    public static void main(String[] args) {
        //1.提示用户输入学生的人数并使用变量记录
        System.out.println("请输入学生的人数:");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        //2.根据学生的人数准备对应的一维数组
        //声明一个长度为num元素类型为student类型的一维数组
        //数组中的每个元素都是student类型，也就是说数组中的每个元素都可以看做student类型的变量| arr[0]=new Student();
        Student[] arr = new Student[num];
        //3.提示用户输入每个学生的信息（学号姓名）并记录到一维数组中
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i+1) + "个学生的信息(学号 姓名):");
            arr[i] = new Student(sc.nextInt(),sc.next());
        }
        System.out.println("------------------------------------");
        //4.打印所有学生信息
        System.out.println("该班级的所有学生信息有：");
        for (int i = 0; i < arr.length; i++) {
//            System.out.println("学号为" + arr[i].getId() + "的学生名字叫" + arr[i].getName());
            arr[i].show();
        }
    }
}

六、JavaBean的概念（了解）

  • JavaBean是一种Java语言写成的可重用组件，其它Java 类可以通过反射机制发现和操作这些JavaBean 的属性。
  • JavaBean本质上就是符合以下标准的Java类：
  1. 类是公共的
  2. 有一个无参的公共的构造器
  3. 有属性，且有对应的get、set方法

归纳总结

  1. 构造方法（重中之重）
    语法格式、默认构造方法、实现成员变量的初始化
  2. 方法重载（重点）
    概念、体现形式、实际意义
  3. this关键字（原理）
    概念、原理、使用方式
  4. 递归（难点）
    概念、使用原则
  5. 封装（重中之重）
    概念、实现流程
akiaug
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值