• java学习day7（Java基础）方法和封装

    今日重点：
    1. 构造方法
    2. 方法重载
    3. this关键字
    4. 方法递归调用
    5. 封装
    第一节：构造方法（重中之重）
    构造方法的基本概念
    • class 类名 {
    类名(形参列表) {
    构造方法体;
    }
    } 
    1. class Person {
    2. Person() { - Person类中的构造方法
    3. }
    4. }

    • 构造方法名与类名完全相同并且没有返回值类型，连void都不许有。

    默认构造方法

    • 当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造构造方法，叫做默认/缺省构造方法，如：Person(){}
    • 若类中出现了构造方法，则编译器不再提供任何形式的构造方法。 
    1. /*
    2.     编程实现Person类的定义
    3.  */
    4. public class Person {
    5. 	
    6. 	String name; // 用于描述姓名的成员变量
    7. 	int age;     // 用于描述年龄的成员变量
    8. 	
    9. 	// 自定义构造方法
    10. 	// String s = "张飞";
    11. 	// int i = 30;
    12. 	// String s = "关羽";
    13. 	// int i = 35;
    14. 	// 就近原则  懒人原则  
    15. 	Person(String name, int age) {
    16. 		//System.out.println("我就是自定义的构造方法！");
    17. 		//name = "张飞";
    18. 		//age = 30;
    19. 		this.name = name;
    20. 		this.age = age;
    21. 	}
    22. 	// 自定义无参构造方法
    23. 	Person() {
    24. 	}
    25. 	
    26. 	// 自定义成员方法实现所有特征的打印  隐含着this关键字,this关键字代表当前正在调用的对象
    27. 	// Person this = p1;   this.name = p1.name = 张飞
    28. 	// Person this = p2;   this.name = p2.name = 关羽
    29. 	void show() {
    30. 		// 每当打印成员变量的数值时，让年龄增长一岁
    31. 		//this.grow();
    32. 		//grow();
    33. 		//System.out.println("我是" + this.name + "，今年" + this.age + "岁了！");
    34. 		System.out.println("我是" + name + "，今年" + age + "岁了！");
    35. 	}
    36. 	// 自定义成员方法实现年龄增长一岁的行为
    37. 	void grow() {
    38. 		age++;
    39. 	}
    40. 	// 自定义成员方法实现年龄增长参数指定数值的行为
    41. 	void grow(int age) {
    42. 		this.age += age;
    43. 	}
    44. 	// 自定义成员方法实现Person类型对象的获取并返回的行为
    45. 	//String getName(){}
    46. 	Person getPerson() {
    47. 		// 返回当前调用对象本身  Person tp = new Person();  return tp;
    48. 		return this;
    49. 	} 
    50. 	
    51. 	public static void main(String[] args) {
    52. 		
    53. 		// 1.声明一个Person类型的引用指向Person类型的对象
    54. 		// 当类中没有提供构造方法时，则下面调用默认构造方法，若类中提供构造方法后，则下面调用类中提供的版本
    55. 		Person p1 = new Person("张飞", 30);
    56. 		// 并打印特征
    57. 		p1.show();  // null 0  张飞  30
    58. 		
    59. 		Person p2 = new Person("关羽", 35);
    60. 		p2.show();  // 关羽 35
    61. 		
    62. 		Person p3 = new Person();
    63. 		p3.show(); // null 0
    64. 		
    65. 		System.out.println("----------------------------------------------------");
    66. 		// 2.实现重载方法的调用和测试
    67. 		p1.grow();
    68. 		p1.show(); // 张飞 31
    69. 		p1.grow(3);
    70. 		p1.show(); // 张飞 34
    71. 		
    72. 		System.out.println("----------------------------------------------------");
    73. 		// 3.调用成员方法获取对象
    74. 		Person p4 = p1.getPerson();
    75. 		System.out.println("p1 = " + p1);
    76. 		System.out.println("p4 = " + p4);
    77. 		
    78. 	}
    79. }
    构造方法的作用
    • 使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作。

     案例题目

    • 编程实现Point类的定义并向Point类添加构造方法
    Point() 默认创建原点对象
    Point(int i, int j) 根据参数创建点对象 
    1. /*
    2.     编程实现Point类的定义
    3.  */
    4. public class Point {
    5. 	
    6. 	int x; // 用于描述横坐标的成员变量
    7. 	int y; // 用于描述纵坐标的成员变量
    8. 	
    9. 	// 自定义无参构造方法
    10. 	Point() {}
    11.     // 自定义有参构造方法
    12.     Point(int x, int y) {
    13. 		this.x = x;
    14. 		this.y = y;
    15. 	}	
    16. 	
    17. 	// 自定义成员方法实现特征的打印
    18. 	void show() {
    19. 		System.out.println("横坐标是：" + x + "，纵坐标是：" + y);
    20. 	}
    21. 	// 自定义成员方法实现纵坐标减1的行为
    22. 	void up() {
    23. 		y--;
    24. 	}
    25. 	// 自定义成员方法实现纵坐标减去参数指定数值的行为
    26. 	void up(int y) {
    27. 		this.y -= y;
    28. 	}
    29. 	
    30. 	public static void main(String[] args) {
    31. 		
    32. 		// 1.使用无参方式构造对象并打印特征
    33. 		Point p1 = new Point();
    34. 		p1.show(); // 0 0
    35. 		
    36. 		// 2.使用有参方式构造对象并打印特征
    37. 		Point p2 = new Point(3, 5);
    38. 		p2.show(); // 3 5
    39. 		
    40. 		System.out.println("------------------------------------");
    41. 		// 3.调用重载的成员方法
    42. 		p2.up();
    43. 		p2.show(); // 3 4
    44. 		p2.up(2);
    45. 		p2.show(); // 3 2
    46. 	}
    47. }

    第二节：方法重载（重点）

    方法重载的概念
    • 若方法名称相同，参数列表不同，这样的方法之间构成重载关系(Overload)。 
    1. /*
    2.     编程实现方法重载主要形式的测试
    3.  */
    4. public class OverloadTest {
    5. 	
    6. 	// 自定义成员方法
    7. 	void show() {
    8. 		System.out.println("show()");
    9. 	}
    10. 	void show(int i) { // ok  体现在方法参数的个数不同
    11. 		System.out.println("show(int)");
    12. 	}
    13. 	void show(int i, double d) { // ok  体现在方法参数的个数不同
    14. 		System.out.println("show(int, double)");
    15. 	}
    16. 	void show(int i, int j) { // ok  体现在方法参数的类型不同
    17. 		System.out.println("show(int, int)");
    18. 	}
    19. 	void show(double d, int i) { // ok  体现在方法参数的顺序不同
    20. 		System.out.println("show(double, int)");
    21. 	}
    22. 	/*
    23. 	void show(double a, int b) { // error 与参数变量名无关
    24. 		System.out.println("show(double, int)");
    25. 	}
    26. 	*/
    27. 	/*
    28. 	int show(double d, int i) { // error, 与返回值类型无关
    29. 		System.out.println("show(double, int)");
    30. 	}
    31. 	*/
    32. 	
    33. 	public static void main(String[] args) {
    34. 		
    35. 		// 1.声明OverloadTest类型的引用指向该类型的对象
    36. 		OverloadTest ot = new OverloadTest();
    37. 		// 2.调用show方法
    38. 		ot.show();
    39. 		ot.show(66);
    40. 		ot.show(66, 3.14);
    41. 		ot.show(66, 118);
    42. 		ot.show(3.14, 118);
    43. 		//ot.show(3.14, 66);
    44. 	}
    45. }

    重载的体现形式

    • 方法重载的主要形式体现在：参数的个数不同、参数的类型不同、参数的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好相同。
    • 判断方法能否构成重载的核心：调用方法时能否加以区分。
    练习题目
    • 编程实现为Point类添加重载的成员方法：
    up() – 实现纵坐标减1的功能。
    up(int dy) – 实现纵坐标减去参数指定数值的功能。
    • 测试重载方法的调用规则 
    1. /*
    2.     编程实现Point类的定义
    3.  */
    4. public class Point {
    5. 	
    6. 	int x; // 用于描述横坐标的成员变量
    7. 	int y; // 用于描述纵坐标的成员变量
    8. 	
    9. 	// 自定义无参构造方法
    10. 	Point() {}
    11.     // 自定义有参构造方法
    12.     Point(int x, int y) {
    13. 		this.x = x;
    14. 		this.y = y;
    15. 	}	
    16. 	
    17. 	// 自定义成员方法实现特征的打印
    18. 	void show() {
    19. 		System.out.println("横坐标是：" + x + "，纵坐标是：" + y);
    20. 	}
    21. 	// 自定义成员方法实现纵坐标减1的行为
    22. 	void up() {
    23. 		y--;
    24. 	}
    25. 	// 自定义成员方法实现纵坐标减去参数指定数值的行为
    26. 	void up(int y) {
    27. 		this.y -= y;
    28. 	}
    29. 	
    30. 	public static void main(String[] args) {
    31. 		
    32. 		// 1.使用无参方式构造对象并打印特征
    33. 		Point p1 = new Point();
    34. 		p1.show(); // 0 0
    35. 		
    36. 		// 2.使用有参方式构造对象并打印特征
    37. 		Point p2 = new Point(3, 5);
    38. 		p2.show(); // 3 5
    39. 		
    40. 		System.out.println("------------------------------------");
    41. 		// 3.调用重载的成员方法
    42. 		p2.up();
    43. 		p2.show(); // 3 4
    44. 		p2.up(2);
    45. 		p2.show(); // 3 2
    46. 	}
    47. }

    重载的实际意义

    • 方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本，来实现各种不同的功能。
    • 如：java.io.PrintStream类中的println方法。
    第三节：this关键字（原理）
    this的基本概念
    • 若在构造方法中出现了this关键字，则代表当前正在构造的对象。
    • 若在成员方法中出现了this关键字，则代表当前正在调用的对象。
    • this关键字本质上就是当前类类型的引用变量。 
    1. /*
    2.     编程实现this关键字的使用
    3.  */
    4. public class ThisTest {
    5. 	
    6. 	// 自定义构造方法
    7. 	ThisTest() {
    8. 		// this代表当前正在构造的对象
    9. 		System.out.println("构造方法中：this = " + this);
    10. 	}
    11. 	// 自定义成员方法
    12. 	void show() {
    13. 		// this代表当前正在调用的对象
    14. 		System.out.println("成员方法中：this = " + this);
    15. 	}
    16. 	
    17. 	public static void main(String[] args) {
    18. 		
    19. 		// 1.声明ThisTest类型的引用指向该类型的对象
    20. 		ThisTest tt = new ThisTest();
    21. 		// 2.调用show方法
    22. 		tt.show();
    23. 		System.out.println("main方法中：tt = " + tt);
    24. 		
    25. 		
    26. 		
    27. 	}
    28. }

    工作原理

    • 在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之不同。
    使用方式
    • 当局部变量名与成员变量名相同时，在方法体中会优先使用局部变量(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前缀，明确要求该变量是成员变量（重中之重）。
    • this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以作为方法的返回值（重点）。
    • 在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法（了解） 
    1. /*
    2.     编程实现Boy类的定义
    3.  */
    4. public class Boy {
    5. 	
    6. 	String name; // 用于描述姓名的成员变量
    7. 	
    8. 	// 自定义构造方法
    9. 	Boy() {
    10. 		// 调用本类中的有参构造方法
    11. 		//this("无名");
    12. 		System.out.println("无参构造方法！");
    13. 	}
    14. 	Boy(String name) {
    15. 		// 调用本类中的无参构造方法
    16. 		this();
    17. 		System.out.println("=========有参构造方法！");
    18. 		this.name = name;
    19. 	}
    20. 	// 自定义成员方法实现特征的打印
    21. 	void show() {
    22. 		System.out.println("我的名字是：" + name);
    23. 	}
    24. 	
    25. 	public static void main(String[] args) {
    26. 		
    27. 		// 1.使用无参方式构造对象并打印特征
    28. 		Boy b1 = new Boy();
    29. 		b1.show(); // null
    30. 		
    31. 		System.out.println("-----------------------------------");
    32. 		// 2.使用有参方式构造对象并打印特征
    33. 		Boy b2 = new Boy("张飞");
    34. 		b2.show(); // 张飞
    35. 		
    36. 		System.out.println("-----------------------------------");
    37. 		// 3.引用变量的数值可以为空
    38. 		//Boy b3 = null;
    39. 		//b3.show(); // 编译ok，运行会发生NullPointerException空指针异常   算术异常、数组下标越界异常
    40. 		Boy b3 = b2;
    41. 		b3.show(); // 张飞
    42. 	}
    43. }
    注意事项
    • 引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象。
    • 当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生NullPointerException 异常。
    第四节：方法递归调用（难点）
    案例题目
    • 编程实现参数n的阶乘并返回，所谓阶乘就是从1累乘到n的结果。 
    1. /*
    2.     编程实现累乘积的计算并打印
    3.  */
    4. public class JieChengTest {
    5. 	
    6. 	// 自定义成员方法实现将参数n的阶乘计算出来并返回
    7. 	// 1! = 1;     2! = 1*2;   3! = 1*2*3;   ...   n! = 1*2*3*...*n;
    8. 	int show(int n) { // int n=5; int n = 4; int n = 3; int n = 2;  int n = 1;
    9. 		// 递推的方式 
    10. 		/*
    11. 		int num = 1;
    12. 		for(int i = 1; i <= n; i++) {
    13. 			num *= i;
    14. 		}
    15. 		return num;
    16. 		*/
    17. 		/*
    18. 		    5! = 5 * 4 * 3 * 2 * 1;
    19. 			4! = 4 * 3 * 2 * 1;
    20. 			3! = 3 * 2 * 1;
    21. 			2! = 2 * 1;
    22. 			1! = 1;
    23. 			
    24. 			5! = 5 * 4!;
    25. 			4! = 4 * 3!;
    26. 			3! = 3 * 2!;
    27. 			2! = 2 * 1!;
    28. 			1! = 1;
    29. 			
    30. 			n! = n * (n-1)!;
    31. 		  
    32. 		*/
    33. 		// 递归的方式
    34. 		// 当n的数值为1时，则阶乘的结果就是1
    35. 		/*
    36. 		if(1 == n) {
    37. 			return 1;
    38. 		}
    39. 		*/
    40. 		if(1 == n) return 1;
    41. 		// 否则阶乘的结果就是 n*(n-1)!
    42. 		return n*show(n-1);
    43. 		// show(5) => return 5*show(4); => 120
    44. 		// show(4) => return 4*show(3); => 24 
    45. 		// show(3) => return 3*show(2); => 6
    46. 		// show(2) => return 2*show(1); => 2
    47. 		// show(1) => return 1;         => 1
    48. 	}
    49. 	
    50. 	public static void main(String[] args) {
    51. 		
    52. 		// 1.声明JieChengTest类型的引用指向该类型的对象
    53. 		JieChengTest jct = new JieChengTest();
    54. 		// 2.调用方法进行计算并打印
    55. 		int res = jct.show(5);
    56. 		System.out.println("最终的计算结果是：" + res); // 120
    57. 	}
    58. }

    递归的基本概念

    • 递归本质就是指在方法体的内部直接或间接调用当前方法自身的形式。
    注意事项
    • 使用递归必须有递归的规律以及退出条件。
    • 使用递归必须使得问题简单化而不是复杂化。
    • 若递归影响到程序的执行性能，则使用递推取代之。
    案例题目
    • 编程实现费式数列中第n项的数值并返回。
    • 费式数列： 1 1 2 3 5 8 13 21 …… 
    1. /*
    2.     编程实现费氏数列的计算并打印  功能类/封装类
    3.  */
    4. public class Fee {
    5. 	
    6. 	// 自定义成员方法实现费氏数列中第n项数值的计算并返回，n由参数指定
    7. 	// 1 1 2 3 5 8 13  21 ....
    8. 	int show(int n) { // int n = 5; int n = 4; int n = 3; int n = 2; int n = 1;
    9. 		// 1.使用递归的方式进行计算
    10. 		/*
    11. 		// 当n=1或者n=2时，结果是1
    12. 		if(1 == n || 2 == n) {
    13. 			return 1;
    14. 		}
    15. 		// 否则结果是前两项的和
    16. 		return show(n-1) + show(n-2);
    17. 		// show(5) => return show(4) + show(3); => 5
    18. 		// show(4) => return show(3) + show(2); => 3
    19. 		// show(3) => return show(2) + show(1); => 2
    20. 		// show(2) => return 1;                 => 1
    21. 		// show(1) => return 1;                 => 1
    22. 		*/
    23. 		// 2.使用递推的方式进行计算
    24. 		int ia = 1;
    25. 		int ib = 1;
    26. 		for(int i = 3; i <= n; i++) {
    27. 			int ic = ia + ib;
    28. 			ia = ib;
    29. 			ib = ic;
    30. 		}
    31. 		return ib;
    32. 	}
    33. }

    1. /*
    2.     编程实现对费氏数列类的测试  测试类
    3.  */
    4. public class FeeTest {
    5. 	
    6. 	public static void main(String[] args) {
    7. 	
    8. 		// 1.声明FeeTest类型的引用指向该类型的对象
    9. 		Fee ft = new Fee();
    10. 		// 2.调用方法计算并打印
    11. 		int res = ft.show(55);
    12. 		System.out.println("计算的结果是：" + res); // 5
    13. 	}
    14. }

    第五节：封装（重中之重）

    封装的概念
    • 通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符。
    • 为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装。
    封装的实现流程
    • 私有化成员变量，使用private关键字修饰。
    • 提供公有的get和set方法，并在方法体中进行合理值的判断。
    • 在构造方法中调用set方法进行合理值的判断。 
    1. /*
    2.     编程实现Student类的封装  封装类
    3.  */
    4. public class Student {
    5. 	
    6. 	// 1.私有化成员变量，使用private关键字修饰
    7. 	// private关键字修饰表示私有的含义，也就是该成员变量只能在当前类的内部使用
    8. 	private int id;       // 用于描述学号的成员变量
    9. 	private String name;  // 用于描述姓名的成员变量 
    10. 	
    11. 	// 3.在公有的构造方法中调用set方法进行合理值的判断
    12. 	public Student() {}
    13. 	public Student(int id, String name) {
    14. 		//this.id = id;
    15. 		//this.name = name;
    16. 		setId(id);
    17. 		setName(name);
    18. 	}
    19. 	
    20. 	// 2.提供公有的get和set方法，并在方法体中进行合理值的判断
    21. 	// 使用public关键字修饰表示公有的含义，也就是该方法可以在任意位置使用
    22. 	public int getId() {
    23. 		return id;
    24. 	}
    25. 	public void setId(int id) {
    26. 		if(id > 0) {
    27. 			this.id = id;
    28. 		} else {
    29. 			System.out.println("学号不合理哦！！！");
    30. 		}
    31. 	}
    32. 	public String getName() {
    33. 		return name;
    34. 	}
    35. 	public void setName(String name) {
    36. 		this.name = name;
    37. 	}
    38. 	
    39. 	// 自定义成员方法实现特征的打印
    40. 	// 什么修饰符都没有叫做默认的访问权限，级别介于private和public之间
    41. 	public void show() {
    42. 		//System.out.println("我是" + name + "，我的学号是" + id);
    43. 		System.out.println("我是" + getName() + "，我的学号是" + getId());
    44. 	}
    45. }
    1. /*
    2.     编程实现Student类的测试
    3.  */
    4. public class StudentTest {
    5. 	
    6. 	public static void main(String[] args) {
    7. 		
    8. 		// 1.声明Student类型的引用指向Student类型的对象
    9. 		Student s1 = new Student();
    10. 		// 2.对成员变量进行赋值并打印
    11. 		//s1.id = -1001;
    12. 		//s1.name = "张飞";
    13. 		s1.setId(-1001);
    14. 		s1.setName("张飞");
    15. 		s1.show(); // 1001 张飞
    16. 		
    17. 		System.out.println("----------------------------------------------------");
    18. 		// 3.使用有参方式构造对象并打印特征
    19. 		Student s2 = new Student(-1001, "张飞");
    20. 		s2.show(); 
    21. 	}
    22. }
    案例题目
    • 提示用户输入班级的学生人数以及每个学生的信息，学生的信息有：学号、姓名，最后分别打印出来。
    • 提示：Student[] arr = new Student[num]; 
    1. /*
    2.     编程实现学生信息的录入和打印
    3.  */
    4.  
    5. import java.util.Scanner; 
    6.  
    7. public class StudentTest2 {
    8. 	
    9. 	public static void main(String[] args) {
    10. 		
    11. 		// 1.提示用户输入学生的人数并使用变量记录
    12. 		System.out.println("请输入学生的人数：");
    13. 		Scanner sc = new Scanner(System.in);
    14. 		int num = sc.nextInt();
    15. 		
    16. 		// 2.根据学生的人数准备对应的一维数组
    17. 		// int[] arr = new int[3];  - 表示声明一个长度为3元素类型为int类型的一维数组
    18. 		// 数组中的每个元素都是int类型，也就是说数组中的每个元素都可以看做是一个int类型的变量，使用整数数据进行初始化 arr[0] = 10;
    19. 		// 下面的代码是声明一个长度为num元素类型为Student类型的一维数组
    20. 		// 数组中的每个元素都是Student类型，也就是说数组中的每个元素都可以看做Student类型的变量，arr[0] = new Student();
    21. 		Student[] arr = new Student[num];
    22. 		
    23. 		
    24. 		// 3.提示用户输入每个学生的信息(学号 姓名)并记录到一维数组中
    25. 		for(int i = 0; i < num; i++) {
    26. 			System.out.println("请输入第" + (i+1) + "个学生的信息(学号 姓名)：");
    27. 			arr[i] = new Student(sc.nextInt(), sc.next());
    28. 		}
    29. 		
    30. 		System.out.println("-----------------------------------------------");
    31. 		// 4.打印所有学生信息
    32. 		System.out.println("该班级的所有学生信息有：");
    33. 		for(int i = 0; i < num; i++) {
    34. 			//System.out.println(arr[i]);
    35. 			arr[i].show();
    36. 		}
    37. 	}
    38. }

    JavaBean的概念（了解）

    • JavaBean是一种Java语言写成的可重用组件，其它Java 类可以通过反射机制发现和操作这些JavaBean 的属性。
    • JavaBean本质上就是符合以下标准的Java类：
     类是公共的
     有一个无参的公共的构造器
     有属性，且有对应的get、set方法
  • 相关阅读:
    9月14日计算机视觉基础学习笔记——基本图像处理
    react create-react-app v5配置 px2rem （暴露 eject方式）
    mysql字符转换时的注意事项
    vulnhub靶场之HACKSUDO: THOR
    【docker】Docker网络与iptables
    go语言数组、切片和指针
    UE要素控制显隐
    17 软专
    B2B营销新策略 | B2B企业如何实现产品导向增长目标（附方案下载）
    MySQL事务控制
  • 原文地址：https://blog.csdn.net/gaosong0623/article/details/126763277