六.面向对象编程(上)

 本篇文章是根据视频学的，来源如下所示：

教程来源：	java基础到高级_零基础自学Java–尚硅谷–宋红康
教程视频地址：	java基础到高级_零基础自学Java--尚硅谷--宋红康_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1ny4y1Y7CW

目录

1.面向对象编程学习的主线

2.理解面向过程与面向对象

3.两个要素:类和对象

4.类的结构:属性和方法

5.类和对象的创建

6.类和对象的创建

7.对类和对象创建的再理解

8.体会类的多个对象的关系

9.对象的内存解析

10.属性与局部变量的对比1

11.属性与局部变量的对比2

12.方法举例与声明的格式

13.方法的声明1

14.方法声明的说明2

15.return关键字的使用

16.方法使用的注意点

17.课后练习1:类的使用

18.课后练习2

19.课后练习3

20.课后练习4

21.每日一考1

22.每日一考2

23.理解"万事万物皆是对象"

24.对象数组的内存解析

25.匿名对象的使用

26.自定义数组的工具类

27.理解方法的重载

28.方法重载的细节说明

29.重载的举例与判断练习

30.重载的练习：编码实践

31.新特性：可变个数形参的方法

32.理解变量的赋值

33.值传递机制：针对基本数据类型

34.值传递机制：针对引用数据类型

35.值传递机制的练习（本节视频建议看两遍）

36.探讨几道网红题

37.参数传递的编码练习

38.递归方法的使用

39.递归方法的举例

40.每日一考

41.封装性的引入

42.封装性的体现

43.四种权限修饰的理解

44.四种权限修饰的测试

45.封装性的练习：基本使用

46.构造器的基本理解

47.构造器使用的细节说明

48.构造器练习：基本使用

49.构造器练习：三角形

50.总结赋值的过程

51.JavaBean的使用

52.介绍UML类图 

53.this调用属性和方法

54.this调用构造器

55.this练习：boy和girl

56.综合练习1：Account和Customer

57.综合联系2：对象数组

58.package关键字的使用

59.MVC设计模式的理解

60.import关键字的使用

61.每日一考

---

1.面向对象编程学习的主线

/*
 * 一.java的三条主线(第4-6章节)---------面向对象的编程思想(思想的体现)
 * 1.java类及其成员:属性 方法 构造器; 代码块 内部库
 * 2.面向对象的三大特征:封装性 多态性 继承性(抽象性)
 * 3.其他关键字:this super static final abstract interface package import
 * 
 *"大处着眼,小处着手"-------"顿悟"与"渐悟"
 */

2.理解面向过程与面向对象

*2.面向对象:强调了具备功能的对象,以类/对象为最小的单位,考虑谁来做.(面向对象比面向过程更加高一些)
 *人
 *{
 *		打开(冰箱)
 *			{
 *				冰箱.开开();
 *				}
 *		抬起(大象)
 *			{
 *				大象.进入(冰箱)
 *				}
 *		关闭(冰箱)
 *			{				
 *				冰箱.关关（）；
 *				}
 *}
 *冰箱
 *{
 *		开开(){}；
 *		关关(){}；
 *}
 *大象
 *{
 *		进入(冰箱)
 *			{}；
 *		}
 *

3.两个要素:类和对象

*三.面向对象的两个要素:
 *类:对一类事物的描述,是抽象的 概念上的定义
 *对象:是实际存在的事物的个体,是实例化的过程
 *>面向对象程序设计的重点是类的设计
 *>设计类就是设计类的成员的过程
 */

4.类的结构:属性和方法

5.类和对象的创建

/*
 * 一.设计类就是设计类的成员
 * 属性 = field = 成员变量 = 域 字段
 * 方法 = method = 成员方法 = 函数
 * 
 */

6.类和对象的创建

package com.atguigu.java;
/*
 * 一.设计类就是设计类的成员
 * 属性 = field = 成员变量 = 域 字段
 * 方法 = method = 成员方法 = 函数
 * 
 * 创建对象=对象的实例化=实例化类
 * 
 * 二.类和对象的使用(面向对象思想落地的实现)
 * (1)创建类,设计类的成员
 * (2)创建类的对象
 * (3)调用对象的结构,方式:"对象.属性" "对象.方法"
 */

public class PersonTest {
public static void main(String[] args) {
	//实例化对象
	Person p1 = new Person() ;
	//调用相应的属性与方法
	//调用属性:相应的格式是 对象.属性
	p1.name = "Yang";
	p1.age = 23;
	p1.ismale = true;
	System.out.println(p1.name);
	//调用方法:相应的格式是 对象.方法
	p1.eat();
	p1.sleep();
	p1.talk("Chinese");
}
}
class Person
{
	//属性
	String name;
	int age;
	boolean ismale;
	
	//方法
	public void eat()
	{
		System.out.println("人可以吃饭!");
	}
	public void sleep()
	{
		System.out.println("人可以睡觉呀");
	}
	public void talk(String language)
	{
		System.out.println("说的语言是" + language);
	}
}

7.对类和对象创建的再理解

• 白马非马问题-------课上引出
• 本节课只是对类和对象在思想层面上用语言进一步讲解

8.体会类的多个对象的关系

package com.atguigu.java;
/*
 * 一.设计类就是设计类的成员
 * 属性 = field = 成员变量 = 域 字段
 * 方法 = method = 成员方法 = 函数
 * 
 * 创建对象=对象的实例化=实例化类
 * 
 * 二.类和对象的使用(面向对象思想落地的实现)
 * (1)创建类,设计类的成员
 * (2)创建类的对象
 * (3)调用对象的结构,方式:"对象.属性" "对象.方法"
 * 
 * 三.如果创建了多个对象,则每个对象有着自己的独立一套属性
 */

public class PersonTest {
public static void main(String[] args) {
	//实例化对象
	Person p1 = new Person() ;
	//调用相应的属性与方法
	//调用属性:相应的格式是 对象.属性
	p1.name = "Yang";
	p1.age = 23;
	p1.ismale = true;
	System.out.println(p1.name);
	//调用方法:相应的格式是 对象.方法
	p1.eat();
	p1.sleep();
	p1.talk("Chinese");
	
	//*************************没有初始化的情况
	Person p2 = new Person();
	System.out.println(p2.name);//null
	System.out.println(p2.age);//0
	System.out.println(p2.ismale);//false
	
	Person p3 = new Person();
	p3 = p1;//千万要注意这一句话的存在,使得p3与p1的堆区空间指向是一样的
	p3.age = 28;
	System.out.println(p1.age);//p1与p3的age是相同的
	
	
}
}
class Person
{
	//属性
	String name;
	int age;
	boolean ismale;
	
	//方法
	public void eat()
	{
		System.out.println("人可以吃饭!");
	}
	public void sleep()
	{
		System.out.println("人可以睡觉呀");
	}
	public void talk(String language)
	{
		System.out.println("说的语言是" + language);
	}
}

9.对象的内存解析

• 堆:存放对象实例        栈:存放局部变量        方法区:存放类信息 常量 静态变量 (编译器编译以后的信息)

(缺少一张图片)

10.属性与局部变量的对比1

package com.atguigu.java;
/*
 * 类中属性的使用
 * 
 * 属性(成员变量)VS局部变量
 * 1.相同点：
 * 		1.1定义变量的格式：数据类型 变量名 = 变量值
 * 		1.2先声明，后使用
 * 		1.3变量都有其对应的作用域
 * 2.不同点：
 * 		2.1在类中的声明位置不同
 * 		属性：直接定义在{}之中
 * 		局部变量：声明在方法内、方法形参、代码块、构造器形参、构造器内部的变量
 * 		2.2关于权限修饰符的不同
 * 		属性:在声明属性的时候，指明其权限，使用权限修饰符进行修饰。
 * 		常用的权限修饰符：private、public、缺省、protect
 * 		目前大家使用属性的时候使用缺型就可以
 * 		局部变量:不可以使用权限修饰符
 */
public class UserTest {

}
class User
{
	//属性(或成员变量)
	private String name;
	public int age;
	boolean isMale;
	
	public void talk(String language)//language:形参,也是局部变量
	{
		System.out.println("我们使用" + language + "进行交流");
	}
	public void eat()
	{   String food = "马铃薯";
		System.out.println("北方人喜欢吃" + food);
	}

	
}

11.属性与局部变量的对比2

package com.atguigu.java;
/*
 * 类中属性的使用
 * 
 * 属性(成员变量)VS局部变量
 * 1.相同点：
 * 		1.1定义变量的格式：数据类型 变量名 = 变量值
 * 		1.2先声明，后使用
 * 		1.3变量都有其对应的作用域
 * 2.不同点：
 * 		2.1在类中的声明位置不同
 * 		属性：直接定义在{}之中
 * 		局部变量：声明在方法内、方法形参、代码块、构造器形参、构造器内部的变量
 * 		2.2关于权限修饰符的不同
 * 		属性:在声明属性的时候，指明其权限，使用权限修饰符进行修饰。
 * 		常用的权限修饰符：private、public、缺省、protect
 * 		目前大家使用属性的时候使用缺型就可以
 * 		局部变量:不可以使用权限修饰符
 * 		2.3默认初始化值
 * 		属性:类的属性都是有初始化值的.
 * 		(整形数据:int short byte  long 的初值时0 )
 * 	       （浮点型：float double 初始值是0.0）
 * 		（字符型：char 初始值是0或者\u0000）
 * 		(布尔类型boolean 初始值是false)
 * 		(引用数据类型:null  接口之类的)
 * 
 * 		局部变量:必须被初始化,没有默认初始值
 * 		2.4在内存之中加载的位置
 * 		属性:加载到堆空间
 * 		局部变量:加载到栈空间
 * 		
 */
public class UserTest {
public static void main(String[] args) {
	User u1 = new User();
	System.out.println(u1.name);
	System.out.println(u1.age);
	System.out.println(u1.isMale);
	u1.talk("日语");
	u1.eat();
}
}
class User
{
	//属性(或成员变量)
	String name;
	public int age;
	boolean isMale;
	
	public void talk(String language)//language:形参,也是局部变量
	{
		System.out.println("我们使用" + language + "进行交流");
	}
	public void eat()
	{   String food = "马铃薯";
		System.out.println("北方人喜欢吃" + food);
	}
	
}

12.方法举例与声明的格式

package com.atguigu.java;
/*
 * 类之中的方法的声明和使用
 * 方法:描述类应该具有的功能
 * 比如:Math类:sqrt()\random()
 * 		Scanner类:nextXXX()
 * 		Arrays类:sort()\binarySearch()\toString()\equals()
 * 
 * 1.举例:public void eat() public void sleep(int hour) public String getName()
 * 	      public String getNation(String nation)
 * 注意:ctrl + shift + t 进入一个类,填写Arrays,ctrl + o,填写sort  可以看到void的介绍
 * 2.方法的声明:权限修饰符 返回值类型 方法名(形参列表){方法体}
 * 
 */
public class CustomerTest {

}
class Customer
{
	//属性:
	String name;
	int age;
	boolean isMale;
	
	//方法:
	public void eat()
	{
		System.out.println("和客户吃饭");
	}
	public void sleep(int hour)
	{
		System.out.println("休息了" + hour + "个小时");
	}
	public String getName()
	{
		return name;
	}
	public String getNation(String nation)
	{
		String info = "我的国籍是" + nation;
		return info;
		
	}
}

13.方法的声明1

package com.atguigu.java;
/*
 * 类之中的方法的声明和使用
 * 方法:描述类应该具有的功能
 * 比如:Math类:sqrt()\random()
 * 		Scanner类:nextXXX()
 * 		Arrays类:sort()\binarySearch()\toString()\equals()
 * 
 * 1.举例:public void eat() public void sleep(int hour) public String getName()
 * 	      public String getNation(String nation)
 * 注意:ctrl + shift + t 进入一个类,填写Arrays,ctrl + o,填写sort  可以看到void的介绍
 * 2.方法的声明:权限修饰符 返回值类型 方法名(形参列表){方法体}
 *   注意:static final abstract 来修饰的方法,后面讲
 * 3.说明:
 * 		3.1关于权限修饰符:当前学习阶段的默认是用public
 * 			java的权限修饰符:protect public 缺省 private-----后面封装性的时候详细讲
 * 		3.2返回值类型: 有返回值 VS 没有返回值
 * 			3.2.1如果有返回值,必须在方法声明的时候指定返回值的类型,同时方法之中使用
 * 					引入新的关键字:return返回常量或者相应类型的数据(必须返回的,有条件也必须满足)
 * 					方法声明时如果没有返回值,那么直接用void即可.(通常没有返回值的)
 * 					return ;表示这种方法结束,直接结束即可,不用返回返回值,一般在void之中使用
 * 					上述是结束方法的使用方式
 * 			3.2.2我们定义一个方法该不该有返回值?
 * 					(1)题目要求:返回一个什么
 * 					(2)经验
 * 
 */
public class CustomerTest {
public static void main(String[] args) {
	Customer c1 = new Customer();
	c1.eat();
	c1.getName();
}
}
class Customer
{
	//属性:
	String name;
	int age;
	boolean isMale;
	
	//方法:
	public void eat()
	{
		System.out.println("和客户吃饭");
	}
	public void sleep(int hour)
	{
		System.out.println("休息了" + hour + "个小时");
	}
	public String getName()//一定要返回,否则报错
	{
		if(age > 13)
		{
		return name;
		}
		else{
		return "Tom";
		}
	}
	public String getNation(String nation)
	{
		String info = "我的国籍是" + nation;
		return info;
		
	}
}

14.方法声明的说明2

package com.atguigu.java;
/*
 * 类之中的方法的声明和使用
 * 方法:描述类应该具有的功能
 * 比如:Math类:sqrt()\random()
 * 		Scanner类:nextXXX()
 * 		Arrays类:sort()\binarySearch()\toString()\equals()
 * 
 * 1.举例:public void eat() public void sleep(int hour) public String getName()
 * 	      public String getNation(String nation)
 * 注意:ctrl + shift + t 进入一个类,填写Arrays,ctrl + o,填写sort  可以看到void的介绍
 * 2.方法的声明:权限修饰符 返回值类型 方法名(形参列表){方法体}
 *   注意:static final abstract 来修饰的方法,后面讲
 * 3.说明:
 * 		3.1.关于权限修饰符:当前学习阶段的默认是用public
 * 			java的权限修饰符:protect public 缺省 private-----后面封装性的时候详细讲
 * 		3.2.返回值类型: 有返回值 VS 没有返回值
 * 			3.2.1如果有返回值,必须在方法声明的时候指定返回值的类型,同时方法之中使用
 * 					引入新的关键字:return返回常量或者相应类型的数据(必须返回的,有条件也必须满足)
 * 					方法声明时如果没有返回值,那么直接用void即可.(通常没有返回值的)
 * 					return ;表示这种方法结束,直接结束即可,不用返回返回值,一般在void之中使用
 * 					上述是结束方法的使用方式
 * 			3.2.2我们定义一个方法该不该有返回值?
 * 					(1)题目要求:返回一个什么
 * 					(2)经验
 * 		3.3.方法名:属于标识符,见名知意
 * 		3.4.形参列表:方法可以声明0个或者1个也可以多个
 * 			3.4.1格式:数据类型1 形参1,数据类型2 形参2
 * 			3.4.2我们定义方法时候要不要形参?
 * 				(1)题目要求:UML图----去声明要求
 *		3.5.方法体:方法的功能的实现.
 * 
 * 
 */
public class CustomerTest {
public static void main(String[] args) {
	Customer c1 = new Customer();
	c1.eat();
	c1.getName();;
	int[] arr = new int[]{1,2,3,3,3,4,5,6,3,3,4};
	//c1.sort(arr);测试形参是否需要
}
}
class Customer
{
	//属性:
	String name;
	int age;
	boolean isMale;
	
	//方法:
	public void eat()
	{
		System.out.println("和客户吃饭");
	}
	public void sleep(int hour)
	{
		System.out.println("休息了" + hour + "个小时");
	}
	public String getName()//一定要返回,否则报错
	{
		if(age > 13)
		{
		return name;
		}
		else{
		return "Tom";
		}
	}
	
	
}

15.return关键字的使用

 *  return关键字的使用:
 *  	1.适用范围:使用在方法体之中
 *  	2.作用:(1)结束方法
 *  		   (2)针对有返回值的类型的方法,使用"return 数据"的方式
 *      3.注意点:return后面不可以声明执行语句.

16.方法使用的注意点

 *  5.方法的使用注意:可以调用当前类的属性或方法
 *  		特殊:方法A之中又调用了A--递归
 *  		方法之中不可以定义方法.(错误)

17.课后练习1:类的使用

• 题目

•  Person4.java

package com.atshangguigu.exer;

public class Person4 {
	String name;
	int age;
	/**
	 * sex:1表明是男性
	 * sex:0表明是女性
	 */
	int sex;
	
	public void study()//说明书里面的+是代表着public
	{
		System.out.println("studying");
	}
	public void showAge()
	{
		System.out.println("age" + "=" + age );
	}
	public int addAge(int i)
	{
		age += i;
		return age;
	}
}

• PersonTest.java

package com.atshangguigu.exer;
/*
 * 要求：(1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串
 * “studying”，调用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。
 * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
 */
public class PersonTest {
public static void main(String[] args) {
	Person4 p1 = new Person4();
	p1.name = "Yang";
	p1.age = 23;//没有女朋友
	p1.sex = 1;
	p1.study();
	p1.showAge();
	int newAge = p1.addAge(2);//这个2在栈里面
	System.out.println(p1.name + "的新年龄是:" + newAge);//25
	System.out.println(p1.age);//25 这里需要注意
	
	/********/
	Person4 p2 = new Person4();
	p2.showAge();//0
	p2.addAge(10);
	p2.showAge();
}
}

18.课后练习2

package com.atshangguigu.exer;
/*
 * 利用面向对象的编程方法，设计类Circle计算圆的面积。
 */
//测试类
public class CirCleTest {
public static void main(String[] args) {
	Circle c1 = new Circle();
	c1.radius = 12.5;
	
	//double c2 = c1.findArea();
	//System.out.println(c2);
	c1.findArea();
}
}

//圆
class Circle
{
	//属性
	double radius;
	
	//方法
	//方式一:
	//public double findArea()
	//{
	//	return (Math.PI * radius * radius);//Math.PI
	//}
	//方式二:
	public void  findArea()
	{
		double area = Math.PI * radius * radius;
		System.out.println("面积为:" + area);
	}
	
	
}

19.课后练习3

package com.atshangguigu.exer;

/*
3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形， 在main方法中调用该方法。 
3.2 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再
计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法，
接收返回的面积值并打印。
3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个
m*n的*型矩形，并计算该矩形的面积， 将其作为方法返回值。在main方法
中调用该方法，接收返回的面积值并打印。
 */
public class Exer3Test {
public static void main(String[] args) {
	Exer3Test test = new Exer3Test();
	//test.method();//3.1
	/*3.2
	 * 方式一
	int area  = test.method1();
	System.out.println("面积为" + area);
	*/
	//方式二
	//System.out.println(test.method1());
	//3.3
	System.out.println(test.method2(3,8));
	
}
/*3.1
public void method()
{
	for(int i = 0;i < 10;i++)
	{
		for(int j = 0;j < 8;j++ )
		{
			System.out.print("*");
		}
		System.out.println()
	}
	}
	*/
/*
public int method1()
{
	for(int i = 0;i < 10;i++)
	{
		for(int j = 0;j < 8;j++ )
		{
			System.out.print("*");
		}
			System.out.println();
			
	}
	return 8 * 10;
			 
}
*/
public int method2(int m,int n)
{
	for(int i = 0;i < m;i++)
	{
		for(int j = 0;j < n;j++ )
		{
			System.out.print("*");
		}
			System.out.println();
			
	}
	return m * n;
			 
}
}

20.课后练习4

21.每日一考1

22.每日一考2

23.理解"万事万物皆是对象"

 * 一.理解"万事万物皆是对象"这句话(面试的时候可以提一下)
 * 1.在java语言的范畴之中,我们将功能结构等封装到类之中,通过类的实例化,来调用具体的功能结构.
 *   Scanner,string
 *   文件:file
 *   网络资源:URL
 * 2.语言的交互:前端之中STM32骨架(一个硬件或者接口)-----java之中的对象.属性(一个类)----数据库对象(表之中的一条条数据)
 * 		java语言与前段Html 后端的数据库交互时,前后端的结构在java层面的交互都提现为类 对象.
 * 	

24.对象数组的内存解析

• 将栈空间之中的stus:0x7788,指着堆空间之中的数组,且第一个元素指向相应的地址.

25.匿名对象的使用

package com.atshangguigu.java;
/*
 * 一.理解"万事万物皆是对象"这句话(面试的时候可以提一下)
 * 1.在java语言的范畴之中,我们将功能结构等封装到类之中,通过类的实例化,来调用具体的功能结构.
 *   Scanner,string
 *   文件:file
 *   网络资源:URL
 * 2.语言的交互:前端之中STM32骨架(一个硬件或者接口)-----java之中的对象.属性(一个类)----数据库对象(表之中的一条条数据)
 * 		java语言与前段Html 后端的数据库交互时,前后端的结构在java层面的交互都提现为类 对象.
 * 	
 * 二.内存解析的说明
 * 1.引用类型的变量,只可能存储两类值:null或者 地址值(含有变量的类型)
 * 
 * 三.匿名对象
 * 1.理解:我们创建的对象,没有显式的赋给一个变量名,即为匿名对象.
 * 2.特征:匿名的方式造的对象,只能够使用一次.
 * 3.使用:
 * 
 */
public class InstanceTest {
public static void main(String[] args) {
	Phone p = new Phone();//com.atshangguigu.java.phone@15db9742
	//p = null;
	System.out.println(p);
	
	p.sendMail();
	p.playGame();
	
	//匿名
	new Phone().price = 1999;
    new Phone().showPrice();//0.0
    
    /**************************/
    PhoneMall mall = new PhoneMall();
    //mall.show(p);
    //匿名对象的使用
    mall.show(new Phone());//相当于是Phone phone = new Phone();我的理解是
    
}
}
class PhoneMall
{
	public void show(Phone phone)
	{
		phone.sendMail();
		phone.playGame();
	}
}
class Phone
{
	double price;
	
	public void sendMail()
	{
		System.out.println("发送邮件");
	}
	
	public void playGame()
	{
		System.out.println("打游戏");
	}
	
	public void showPrice()
	{
		System.out.println("手机的价格是" + price);
	}

}

26.自定义数组的工具类

• 改名refactory - rename:对类进行改名

package com.atshangguigu.java;
/* ArrayUtil
 * 自定义数组的工具类
 */
public class ArrayUtil {

	//求最大值
	public int getMax(int[] arr)
	{
		int max = arr[0];//最大值
		for(int i = 0;i < arr.length;i++)
		{
			if(max < arr[i])
			{
				max = arr[i];
			}

		}

		return max;
		
	}
	//求最小值
	public int getMin(int[] arr)
	{

		int min = arr[0];//最小值
	
		for(int i = 0;i < arr.length;i++)
		{
		
			if(min > arr[i])
			{
				min = arr[i];
			}
			
		}
	
		return min;
	}
	//求总和
	public int getSum(int[] arr)
	{

		int add = 0;
	
		for(int i = 0;i < arr.length;i++)
		{
		
			add += arr[i];
			
		}

		return add;
		
	}
	//求平均值
	public double getAvg(int[] arr)
	{
	
		int add = 0;
		double ava;
		for(int i = 0;i < arr.length;i++)
		{
			
			add += arr[i];
			
		}
		ava = add/(arr.length);
		return ava;
		
	}
	//反转
	public void reverse(int[] arr)
	{
		for(int i = 0,j = arr.length-1;i < j;i++,j--)  
		{
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		
	}
	//复制
	public int[] copy(int[] arr)
	{
		int[] arr1 = new int[arr.length];
		for(int i = 0;i < arr.length;i++)
		{
			arr1[i] = arr[i];
		}
		return arr1;
		
	}
	//排序
	public void sort(int[] arr)
	{
		for(int i = 0;i < arr.length-1;i++)
		{
			for(int j = 0;j <arr.length-1-i;j++)
			{
				if(arr[j]<arr[j+1])
				{
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
	//遍历
	public void print(int[] arr)
	{
		for(int i = 0;i < arr.length;i++)
		{
			System.out.print(arr[i] + "\t");
		}
	}
	//查找
	public int getIndex(int[] arr,int dest)
	{
		
		for(int i = 0;i < arr.length;i++ )
		{
			if(dest == arr[i])//这里需要注意equals()的使用
			{
				System.out.println("恭喜你,找到啦!");
			
				return i;//替代break
			}
		}
		return -1;//返回一个负数表示没有找到
		
		
	}
}

package com.atshangguigu.java;
/*ArrayUtilTest*/
public class ArrayUtilTest {
public static void main(String[] args) {
	
	ArrayUtil util = new ArrayUtil();
	int[] arr = new int[]{32,3,1,64,56,5,6,99,56,102,95,88,213,1,23,465,114,954};
	int max = util.getMax(arr);
	System.out.println("最大值为" + max);
	System.out.print("排序前:");
	util.print(arr);
	System.out.println();
	System.out.print("排序后:");
	util.sort(arr);
	util.print(arr);

	System.out.println("查找");
	int index = util.getIndex(arr, 5);
	if(index != 0)
	{System.out.println("找到了,索引地址为:" + index);
	}
	else
	{System.out.println("没有找到");
	}
	
	
}
}

27.理解方法的重载

• 重载的概念
  在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。 
  重载的特点：
  与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

28.方法重载的细节说明

package com.atshangguigu.java;
/*
 * 方法的重载(overload) loading......    载入......
 * 1.定义:在同一个类之中,允许存在一个以上的名字相同的方法,只要他们的参数个数或者参数类型不同即可.
 * 		“两同一不同”：同一个类、方法名字相同
 * 					参数列表不同：参数个数不同、参数类型不同
 * 2.举例:java SE8:这个是比较容易理解的,就像两个人穿一样的衣服,但是他们是不一样的人
 * 		Arrays类之中重载sort()/binarySearch()
 * 3.判断是否是重载:
 * 		跟方法的权限修饰符 返回值类型 形参变量名 方法体都没有关系
 * 4.在通过对象调用方法时候,如何确定某一个指定的方法
 * 		方法名   --->  参数列表
 * 		
 */
public class OverLoadTest {
	public static void main(String[] args) {
		OverLoadTest test = new OverLoadTest();
		test.getSum(1,8);//如果注释掉第一个重载,那么自动调用其他的,自动类型提升
	}
	
	
	//如下四个方法构成了重载
	public void getSum(int i,int j)
	{
		System.out.println("1");
	}
	public void getSum(double d1,double d2)
	{
		System.out.println("2");
	}
	public void getSum(int d1,double d2)
	{
		System.out.println("3");
	}
	public void getSum(double d1,String d2)
	{
		System.out.println("4");
	}
	
	//下面这这个与第一个矛盾,不是一个重载的情况
	/*
	 public int getSum(int i,int j)
	{
		System.out.println(i + j);
	}
		 public int getSum(int m,int n)
	{
		System.out.println(m + n);
	}
		 private void getSum(int i,int j)
	{
		System.out.println(i + j);
	}
	 */
}

29.重载的举例与判断练习

• 如下所示：是print类型的一个重载的过程。

30.重载的练习：编码实践

• duplicate 的含义是 重复。老外文化 Yes Yes Yes，因为听不懂，就是这样重复。

package com.atshangguigu.Exer;
/*
1.编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别
    执行平方运算并输出结果，相乘并输出结果，输出字符串信息。在主类的
  main ()方法中分别用参数区别调用三个方法。
  
2.定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法
    求两个double值中的最大值，第三个方法求三个double值中的最大值，
    并分别调用三个方法。
 */
public class OverLoadExer {
	//1.如下三种方法构成了重载
		public void mOL(int i)
		{
			System.out.println(i * i);
		}
		public void mOL(int i,int j)
		{
			System.out.println(i * i);
		}
		public void mOL(String s)
		{
			System.out.println(s);
		}
	//2.如下的三种方法也构成了重载
		public int max(int i,int j)
		{
			return (i > j)? i : j;		
		}
		public double max(double i,double j)
		{
			return (i > j)? i : j;	
		}
		public double max(double i,double j,double k)
		{
			double max = (i > j)? i : j;
			return(max > k)? max : k; 
		}
}

31.新特性：可变个数形参的方法

package com.atshangguigu.java1;
/*
 * 可变个数形参的方法
 * 1.jdk 5.0新增内容
 * 2.具体使用:
 * 	2.1可变个数形参的格式:数据类型 ... 变量名
 * 	2.2当调用可变个数形参的方法的时候,传入的参数个数可以是一个也可以是两个或者多个
 * 	2.3可变个数形参的方法与本类中的方法名相同,形参不同的方法之间构成重载.
 * 	2.4可变个数形参的方法与本类中的方法名相同,形参类型也相同的数组之间不构成重载,换句话说,二者不能共存.
 * 	2.5可变个数形参在方法的形参中,必须声明在末尾
 *  2.6可变个数形参在方法的形参中,最多只能声明一个可变形参.
 *  2.7后面的SQL的学习过程中会用到
 */
public class MethodArgsTest {
public static void main(String[] args) {
	MethodArgsTest test = new MethodArgsTest();
	test.show(12);
	test.show("hello!");
	test.show("hello!","world","没有对象!","学习吧");
	//test.show(new String[]{"AA","BB","CC"});
}
	public void show(int i)
	{
		
	}
	public void show(String s)
	{
		System.out.println("show(String!)");
	}
	public void show(String ...strs)
	{
		System.out.println("show(多个String!)");
		for(int i = 0;i < strs.length;i++)
		{
			System.out.println(strs[i]);
		}
	}
	
	/*
	public void show(String[] strs)
	{
		
	}
	*/
	public void show(int i,String ...strs)//必须声明在末尾
	{
	}
	/*public void show(String ...strs,int i)//必须声明在末尾,这样就是错误的
	{
	}
	*/
}

32.理解变量的赋值

package com.atshangguigu.java1;
/*
 * 关于变量的赋值
 * 
 * 如果变量是基本数据类型,此时赋值的是变量所保存的数据值.
 * 如果变量是引用数据类型,此时赋值的是变量所保存数据的地址值
 */
public class ValueTransferTest {
public static void main(String[] args) {
	System.out.println("*************基本数据类型***********");
	int m = 10;
	int n = m;
	System.out.println("m=" + m + ",n=" + n);
	n = 20;
	System.out.println("m=" + m + ",n=" + n);
	System.out.println("*************引用数据类型***********");
	//引用数据类型的数据类型要么是null要么是地址值
	Order o1 = new Order();
	o1.OrderId = 1000;
	Order o2 = o1;//赋值以后,o1和o2的地址相同,指向也是相同的.
	System.out.println("o1 = " + o1.OrderId + ",o2 = " + o2.OrderId);
	o2.OrderId = 2000;
	System.out.println("o1 = " + o1.OrderId + ",o2 = " + o2.OrderId);
}
}
class Order
{
	int OrderId;
	
	}

33.值传递机制：针对基本数据类型

package com.atshangguigu.java1;
/*
 * 
 * 方法的形参的传输机制:值传递
 * 1.形参:方法定义时,声明的小括号内部的参数
 *   实参:方法调用时,实际传递给形参的数据
 * 2.值传递
 * 如果参数是基本数据类型,此时实参赋给形参的真实数据值.
   如果参数是引用数据类型,此时实参赋给形参的真实地址值.
 */
public class ValueTransferTest1 {
public static void main(String[] args) {
	int m = 10;
	int n = 20;
	System.out.println("m = " + m + ", n =" + n );
	ValueTransferTest1 test = new ValueTransferTest1();
	test.swap(m,n);
	System.out.println("m = " + m + ", n =" + n );
}
	public void swap(int m,int n)
	{
		int temp;
		temp = n;
		n = m;
		m = temp;
	}
}

• 上述代码的过程如下所示

34.值传递机制：针对引用数据类型

package com.atshangguigu.java1;
/*
 * 关于变量的赋值
 * 如果参数是引用数据类型,此时实参赋给形参的是实参存储的地址值.
 */
public class ValueTransferTest2 {
public static void main(String[] args) {
	two test = new two();
	test.m = 50;
	test.n = 80; 
	ValueTransferTest2 test2 = new ValueTransferTest2();
	System.out.println("m = " + test.m + ".n = " + test.n);
	test2.swap(test);
	System.out.println("m = " + test.m + ".n = " + test.n);
	
}
public void swap(two two)
{
	int temp;
	temp = two.m;
	two.m = two.n;
	two.n = temp;			
}
}
class two
{
   int m;
   int n;
}

35.值传递机制的练习（本节视频建议看两遍）

• public class TransferTest3 {
  public static void main(String args []) {
  TransferTest3 test = new TransferTest3();
  test .first();
  }
  public void first() {
  int i = 5;
  Value v = new Value();
  v . i = 25;
  second( v , i );
  System. out .println( v . i );
  }
  public void second(Value v , int i ) {
  i = 0;
  v . i = 20;
  Value val = new Value();
  v = val ;
  System. out .println( v . i + " " + i );
  }
  }

  class Value {

  int i = 15;

  }

  

36.探讨几道网红题

• 题目一

public static void method(int a,int b)
{//在不改变题目的基础上
	a = a * 10;
	b = b * 20;
	System.out.println(a);
	System.out.println(b);
	System.exit(0);
}

• 题目二

• 题目三

package com.atshangguigu.java1;

public class ArrayPrintTest {
public static void main(String[] args) {
	int[] arr = new int[]{1,2,3,4};
	System.out.println(arr);//地址值?
	char[] arr1 = new char[]{'1','2','3','4'};
	System.out.println(arr1); //地址值?
}
}

结果是：
[I@15db9742
1234

原因如左图（西北工业大学的学生进行面试的题目）

37.参数传递的编码练习

•  Circle.java

package com.atshangguigu.Exer1;
/*
 * （1）定义一个Circle类，包含一个double型的radius属性代表
 *  圆的半径，一个findArea()方法返回圆的面积。
 */
public class Circle {
	double radius;//半径
	public double findArea()
	{
		return radius * radius * Math.PI;
	}
}

• PassObject.java

package com.atshangguigu.Exer1;
/*
 * （2）定义一个类PassObject，在类中定义一个方法printAreas()，
 * 该方法的定义如下：public void printAreas(Circle c, int time)
 * 在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
 * 例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
 * （3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。
 * 程序运行结果如图所示
 */
public class PassObject {
public static void main(String[] args) {
	PassObject test = new PassObject();
	Circle c = new Circle();
	test.printAreas(c, 5);
	System.out.println("now the radius is " + c.radius);
}
public void printAreas(Circle c, int times)
{ 
	System.out.println("Radius\t\tArea");
	for(int i = 0;i < times;i++)
	{
		c.radius = i;
		System.out.println(c.radius + "\t\t" +  c.findArea());
	}
	c.radius = c.radius + 2;
	}
}

38.递归方法的使用

• 这个阶段是了解即可

package com.atshangguigu.java2;
/*
 * 递归方法的使用
 * 递归方法：一个方法体内调用它自身。
 * 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
 * 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
 */
public class Recursiontest {
public static void main(String[] args) {
	Recursiontest test = new Recursiontest();
	
	System.out.println(test.getSum(100));
}
	//例1:计算1-n之间所有自然数的和
	//方式一：
	/*
	int sum = 0;
	for(int i = 0;i <=100;i++)
	{
		sum+=i;
	}
	*/
	//方式二:
public int getSum(int n)
{
   if(n == 1 )
   {
	   return 1;
   }
   else 
   {
	   return n + getSum(n-1);
   }
}		
}

39.递归方法的举例

• 斐波那契数列
• 汉诺塔
• 快排

40.每日一考

41.封装性的引入

• 新浪网的员工加班,错过了77万的年终奖
• 封装性的定义:高内聚,低耦合

        高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉;                                               

        低耦合 ：仅对外暴露少量的方法用于使用。

• 思想:隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
• 注意下面的代码之中的legs的存在,这里有一个private

CSDN首页

消息

发文助手


发文助手会对标题提出优化建议，避免出现不恰当文字从而影响文章推荐。【标题规范】

六.面向对象编程(上)
11 / 100

展示封面：
*

优质的封面有利于推荐，格式支持JPEG、PNG
文章标签：
*
分类专栏：
新建分类专栏
最多选择3个分类专栏#为二级分类
文章类型：
申请原创将启用 Creative Commons 版权模板，如果不是原创文章，请选择转载或翻译。 原创文章默认开启打赏， 打赏管理
发布形式：
收益中心 
草稿已保存 21:33:46 共 23519 字
发布文章





package com.atshangguigu.java;
/*
 * 面向对象的特征一:封装与隐藏
 * 一:问题的引入
 *    当我们创建一个类以后,我们可以通过对象.属性的方式,对对象进行赋值.这里的赋值操作是受到
 * 属性的类型以及存储范围的制约.除此之外没有其他的限制.但是,在实际的问题之中,我们往往需要给
 * 属性加一些额外的限制,我们可以通过方法进行条件的添加.(比如说:setLegs),同时我们又要避免用户
 * 使用对象.属性的方式对对象进行赋值,这样的赋值与之前那个的限制可能是有所冲突的,我们可以将其属性
 * 设置为private性质.

 */
public class AnminalTest {
public static void main(String[] args) {
	Anminal a = new Anminal();
	a.name  = "花花变大黄";
	a.age = 1;
	//a.legs = 4;//报错:The field Anminal.legs is not visible
	a.show();
	a.setLegs(8);//告诉用户这种方式是正确的
	a.show();
}
}
class Anminal
{
	String name;
	int age;
	private int legs;//private的使用
	public void setLegs(int l)
	{
		if(l >= 0 && l%2 == 0)
		{
			legs = l;
		}
		else
		{
			legs = 0;
		}
	}
	public void eat()
	{
		System.out.println("看,那里有一堆粮");	
	}
	public void show()
	{
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
	
}

 

42.封装性的体现

package com.atshangguigu.java;
/*
 * 面向对象的特征一:封装与隐藏
 * 一:问题的引入
 *    当我们创建一个类以后,我们可以通过对象.属性的方式,对对象进行赋值.这里的赋值操作是受到
 * 属性的类型以及存储范围的制约.除此之外没有其他的限制.但是,在实际的问题之中,我们往往需要给
 * 属性加一些额外的限制,我们可以通过方法进行条件的添加.(比如说:setLegs),同时我们又要避免用户
 * 使用对象.属性的方式对对象进行赋值,这样的赋值与之前那个的限制可能是有所冲突的,我们可以将其属性
 * 设置为private性质.
 * 
 * 二:封装性的体现
 * 我们将类的属性私有化(private),同时,提供公共的(public)的方法来获取(get**)和设置(set**)此属性的值.
 * 
 * 拓展:封装性的体现:
 * 1.如上
 * 2.不对外暴露的私有的方法
 * 3.单例模式
 */
public class AnminalTest {
public static void main(String[] args) {
	Anminal a = new Anminal();
	a.name  = "花花变大黄";
	a.age = 1;
	//a.legs = 4;//报错:The field Anminal.legs is not visible
	a.show();
	a.setLegs(8);//告诉用户这种方式是正确的
	a.show();
	
}
}
class Anminal
{
	String name;
	int age;
	private int legs;//private的使用
	//对于属性的一个设置
	public void setLegs(int l)//腿的个数
	{
		if(l >= 0 && l%2 == 0)
		{
			legs = l;
		}
		else
		{
			legs = 0;
		}
	}
	//对于属性的一个获取
	public int getLegs()
	{
		return legs;
	}
	public void eat()
	{
		System.out.println("看,那里有一堆粮");	
	}
	public void show()
	{
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
	
	//提供age的get与set的方式
	public int getAge()
	{
		return age;
	}
	public void setAge(int age)
	{
		//限制条件
	}
}

43.四种权限修饰的理解

 * 三.权限修饰符------封装性的提现需要权限修饰符的配合
 * 1.java规定的四种权限:private 缺省 protected public
 * 2.四种权限可以修饰什么:修饰类以及内部结构 属性 方法 构造器 内部类
 * 3.具体的,四种权限都是可以修饰类的内部结构:属性 方法 构造器 内部类
 *         修饰类的话 :只能使用 缺省 public

44.四种权限修饰的测试

• 代码一

package com.atshangguigu.java;

public class Order {
	private int orderPrivate;
	int orderDefault;
	public int orderPublic;
	
	private void methodPrivate()
	{
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	void methodDefault()
	{
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	public void methodPublic()
	{
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	
}

• 代码二

package com.atshangguigu.java;

public class Ordertest {
public static void main(String[] args) {
	Order test = new Order();
	//出了Order之后这里的私有结构是不可以被调用的
	//test.orderPrivate = 1;
	test.orderDefault = 2;
	test.orderPublic = 3;
	
	//同理:方法也是,private类型的是不可被调用的
}
}

• 代码三

package com.atshangguigu.java1;

import com.atshangguigu.java.Order;
//引用如果要是缺省类型的出了包以后也是不可以使用的.
public class OrderTest {
	public static void main(String[] args) {
		Order test = new Order();
		//出了Order之后这里的私有结构是不可以被调用的
		//test.orderPrivate = 1;
		//出了Order类所属的包以后,私有和缺省都是不可以被调用
		//test.orderDefault = 2;
		test.orderPublic = 3;
		
		//同理:方法也是
	}
	
}

• 总结:Java提供了四种权限修饰符来修饰类以及类的内部结构,提现类及类的内部结构在被调用的时候的可见性的大小.

45.封装性的练习：基本使用

• Person.java

package com.atshangguigu.Exer;
/*
	1.创建程序,在其中定义两个类：Person和PersonTest类。定义如下：
	用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。 在 PersonTest 类 中实例化 Person 类的对象 b ， 调 用 setAge() 和
	getAge()方法，体会Java的封装性。
 */
public class Person {
	private int age;
	
	public void getAge(int ag)
	{
		if(ag < 0||ag > 130)
		{
			throw new RuntimeException("传入非法数据!");
			
		}
		else{
		age = ag;
		}
	}
	public int setAge()
	{
		return age;
	}
	
}

• PersonTest.java

package com.atshangguigu.Exer;

public class PersonTest {
public static void main(String[] args) {
	Person test = new Person();
	test.getAge(23);
	System.out.println(test.setAge());
}
}

46.构造器的基本理解

• field属性 constructor构造器 method方法

package com.atshangguigu.java1;
/*
 * 类的结构三:构造器(或者构造方法 constructor)的使用
 * construct:建设,建造 construct:CCB constructor:建设人
 * 一.构造器的使用
 * 创建对象
 * 二.说明
 * 1.如果没有显式的定义类的构造器的话,那么系统会默认提供一个空参的构造器
 * 2.定义构造器的格式:权限修饰符+类名(形参列表)
 * 3.构造器的的功能是构造一个对象,注意与方法的区别
 */
public class PersonTest {
public static void main(String[] args) {
	//过程2:创建对象:new + 构造器
	Person test = new Person();
	test.eat();
}
}

// 过程1:创建类
class Person {
	//属性
	int age;
	String name;
	
	//构造器
	public Person()
	{
		System.out.println("构造器");
	}
	
	//方法
	public void eat() {
		System.out.println("我一顿吃两份饭!");
	}

	public void sleep() {
		System.out.println("我可以连着睡12个小时");
	}

}

47.构造器使用的细节说明

package com.atshangguigu.java1;
/*
 * 类的结构三:构造器(或者构造方法 constructor)的使用
 * construct:建设,建造 construct:CCB constructor:建设人
 * 一.构造器的使用:也就两个作用
 * 1.创建对象
 * 2.初始化对象的属性(信息)
 * 二.说明
 * 1.如果没有显式的定义类的构造器的话,那么系统会默认提供一个空参的构造器
 * 2.定义构造器的格式:权限修饰符+类名(形参列表)
 * 3.构造器的的功能是构造一个对象,注意与方法的区别
 * 4.一个类之中定义多个构造器可以彼此构成重载
 * 5.这里需要注意,一旦定义了别的构造器,默认的构造器是不存在的------"扶贫策略"
 * 6.一个类之中至少有一个构造器
 */
public class PersonTest {
public static void main(String[] args) {
	//过程2:创建对象:new + 构造器
	Person test = new Person();
	test.eat();
	
	Person p1 = new Person("Tom");
	System.out.println(p1.name);
}
}

// 过程1:创建类
class Person {
	//属性
	int age;
	String name;
	
	//构造器
	public Person()
	{
		System.out.println("构造器");
	}
	public Person(String n)//这里的作用是初始化一个属性的过程
	{
		name = n;
	}
	public Person(String n,int a)
	{
		name = n;
		age = a;
	}
	
	//方法
	public void eat() {
		System.out.println("我一顿吃两份饭!");
	}

	public void sleep() {
		System.out.println("我可以连着睡12个小时");
	}

}

48.构造器练习：基本使用

package com.atshangguigu.java1;
/*
1. 在前面定义的Person类中添加构造器，利用构造器设置所有人的age属
	性初始值都为18。
2. 修改上题中类和构造器，增加name属性,使得每次创建Person对象的同
	时初始化对象的age属性值和name属性值。
 */
public class ConstructorTsest {
public static void main(String[] args) {
	Person1 p = new Person1();
	System.out.println("年龄是" + p.setAge());
	
	Person1 p2 = new Person1("Yang",23);
	System.out.println("姓名是" + p2.setName());
}
}
 class Person1
{
	//属性 
	private int age;
	private String name;
	
	//构造器
	public Person1()
	{
		age = 18;
	}
	public Person1(String n,int a)
	{
		name = n;
		age = a;
	}
	
	//方法
	public void getAge(int ag)
	{
		age = ag;
	}
	public int setAge()
	{
		return age;
	}
	public void getName(String na )
	{
		name = na;
	}
	public String setName()
	{
		return name;
	}	
}	

49.构造器练习：三角形

• TriAngle.java

package com.atshangguigu.Exer1;
/*
		编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，
	同时声明公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计
	算三角形的面积。
 */
public class TriAngle {
	//属性
	private double base;//底边长
	private double height;//高
	
	//构造器
	public TriAngle()
	{
		
	}
	public TriAngle(double b,double c)
	{
		base = b;
		height = c;
	}
	
	//方法
	public void setBase(double b)
	{
		base = b;
	}
	public double getBase()
	{
		return base;
	}
	public void setHeight(double b)
	{
		height = b;
	}
	public double getHeight()
	{
		return height;
	}
}

• TriAngleTest.java

package com.atshangguigu.Exer1;

public class TriAngleTest {
public static void main(String[] args) {
	//调用空参的构造器
	TriAngle t1 = new TriAngle();
	t1.setBase(45.3);
	t1.setHeight(175.0);
	System.out.println("base:" + t1.getBase() + ",height:" + t1.getHeight());
	
	//调用含有参数的构造器
	TriAngle t2 = new TriAngle(18,16);
	System.out.println("base:" + t2.getBase() + ",height:" + t2.getHeight());
}
}

50.总结赋值的过程

package com.atshangguigu.java1;
/*
 * 总结:属性赋值先后顺序
 * 
 * ①默认初始化值
 * ②显式初始化值
 * ③构造器之中赋值
 * ④通过"对象.方法"或者"对象.属性"进行赋值
 * 
 * (以上)操作的先后顺序:这里是随意的,需要进行验证.1-2-3-4  主要取决于后面
 */
public class UserTest {
public static void main(String[] args) {
	User u = new User();
	System.out.println(u.age);
	
	User u1 = new User(2);
	u1.setAge(3);
	System.out.println(u1.age);
	
}
}
class User
{
	String name;
	int age = 1;
	
	public User()
	{}
	public User(int a)
	{
		age = a;
	}
	public void setAge(int a)
	{
		age = a;
	}
	public int getAge()
	{
		return age;
	}
}

51.JavaBean的使用

• 这节课听不明白,什么MyS什么什么哪个东西还没学(后面学)

package com.atshangguigu.java1;
/*
 * 所谓javaBean，是指符合如下标准的Java类：
 1.类是公共的
 2.有一个无参的公共的构造器
 3.有属性，且有对应的get、set方法
 * 
 * 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以
用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP
页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用
户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关
心任何改变。-----------涉及到后面的学习

 */
public class Customer {
	
	private String name;
	private int id;
	
	//构造器
	public Customer()
	{}
	
	//方法
	public void getName(String na)
	{
		name = na;
	}
	public String setName()
	{
		return name;
	}
	public void getId(int i)
	{
		id = i;
	}
	public int setId()
	{
		return id;
	}
}

52.介绍UML类图 

• 这里的banking代表着包名

53.this调用属性和方法

• 任何一个知识点:what why how

package com.atshangguigu.java2;
/*
 * this关键字的使用:
 * 1.this可以用来修饰:属性 方法 构造器
 * 2.this修饰属性和方法:
 * 		this可以理解为当前的对象
 * 
 * 2.1	在类的方法之中,我们可以使用this.属性或者this.方法调用相应的对象的属性或者方法.
 * 	但是,通常情况下,我们都选择去忽略this的存在.特殊情况下,如果方法的形参和类的属性
 * 	同名了,我们必须显式的使用this.变量进行,表明此变量是属性,而并非是形参.
 * 2.2	可以在类的构造器之中进行如上的操作,方式相同的.(this表示正在创建的对象和方法)
 */
public class PersonTest {
public static void main(String[] args) {
	Person p1 = new Person();
	p1.setAge(1);
	System.out.println(p1.getAge());
}
}
class Person
{	//属性
	private String name;
	private int age;
	
	//构造器
	public Person()
	{}
	public Person(int age)
	{
		this.age = age;
	}
	public Person(int age,String name)
	{
		this.name = name;
		this.age = age;
	}
	
	//方法:形参的意义在于给上面进行赋值,并且需要"见名知意"
	public void setName(String name)
	{
		this.name = name;//防止属性与上面的形参重名的情况,注意this的使用
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age = age;//这里的this是相当于p1的,是先有类的,在写相应的代码
	}
	public int getAge()
	{
		return age;
	}
	
	public void eat()
	{
		System.out.println("中午了,看完这两节课,我想要去吃饭啦!");
		//data();//方法里面可以调用方法
		//上面的代码相当于下面
		this.data();//this相当于省略了
	}
	public void data()
	{
		System.out.println("今天是2021年10月18日,空气良好!");
	}
	
}

54.this调用构造器

• this();//注意括号里面是否进行参数的填写

//构造器
	public Person()
	{
		this.eat();
		//Person初始化的时候需要注意以下代码(共40行代码)
	}
	public Person(int age)
	{
		this();//直接调用上面的空参构造器
		this.age = age;
		//Person初始化的时候需要注意以下代码(共40行代码)
		//上面的代码不用写了,直接调用上面的构造器
		
	}
	public Person(int age,String name)
	{
		this(age);//调用上面的构造器
		this.name = name;
		this.age = age;
	}

• ctrl + shift + t 进行查找HashMap-------降低代码的冗余

• 本节完整代码如下所示:

package com.atshangguigu.java2;
/*
 * this关键字的使用:
 * 1.this可以用来修饰:属性 方法 构造器(或者调用)
 * 2.this修饰属性和方法:
 * 		this可以理解为当前的对象
 * 
 * 2.1	在类的方法之中,我们可以使用this.属性或者this.方法调用相应的对象的属性或者方法.
 * 	但是,通常情况下,我们都选择去忽略this的存在.特殊情况下,如果方法的形参和类的属性
 * 	同名了,我们必须显式的使用this.变量进行,表明此变量是属性,而并非是形参.
 * 2.2	可以在类的构造器之中进行如上的操作,方式相同的.(this表示正在创建的对象和方法)
 * 
 * 3.this调用构造器
 * (1)我们在类的构造器中,可以使用显式"this(形参列表)"方式,调用本类的其他构造器
 * (2)构造器中不能够使用上述方法去调用自己
 * (3)如果一个类之中有n个构造器,那么最多有n-1个构造器之中使用了"this(形参列表)"
 * (4)规定:this(形参列表)必须声明在当前的构造器的首行,后移会出现错误.
 * (5)构造器的内部,最多声明一个this(形参列表),不能够调用多个this(参数列表)
 */
public class PersonTest {
public static void main(String[] args) {
	/*
	Person p1 = new Person();
	p1.setAge(1);
	System.out.println(p1.getAge());
	*/
	Person p2 = new Person(20,"Jerry");
	System.out.println(p2.getAge());
}
}
class Person
{	//属性
	private String name;
	private int age;
	
	//构造器
	public Person()
	{
		this.eat();
		//Person初始化的时候需要注意以下代码(共40行代码)
		System.out.println(age);
	}
	public Person(int age)
	{
		this();//直接调用上面的空参构造器
		this.age = age;
		//Person初始化的时候需要注意以下代码(共40行代码)
		//上面的代码不用写了,直接调用上面的构造器
		
	}
	public Person(int age,String name)
	{
		this(age);//调用上面的构造器
		this.name = name;
		this.age = age;
	}
	
	//方法:形参的意义在于给上面进行赋值,并且需要"见名知意"
	public void setName(String name)
	{
		this.name = name;//防止属性与上面的形参重名的情况,注意this的使用
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age = age;//这里的this是相当于p1的,是先有类的,在写相应的代码
	}
	public int getAge()
	{
		return age;
	}
	
	public void eat()
	{
		System.out.println("中午了,看完这两节课,我想要去吃饭啦!");
		//data();//方法里面可以调用方法
		//上面的代码相当于下面
		this.data();//this相当于省略了
	}
	public void data()
	{
		System.out.println("今天是2021年10月18日,空气良好!");
	}
	
}

55.this练习：boy和girl

• 注意:软件上面的按钮:source - Generate Getters and Setters[直接加上get  与   set相应的内容]
• 注意:产生一个的构造器,这里的构造器是自动添加的方式:source - Generate Constructor using Fields
• 快捷键:Alt + shift + s
• /** + enter是进行注释,并且放在上面
• Boy.java 

package com.atshangguigu.Exer3;

public class Boy {
	private String name;
	private int age;
	
	public Boy(String name, int age) {
		
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void marry(Girl girl)
	{
		System.out.println("我想娶" + girl.getName());
	}
	public void shout()
	{
		if(this.age >= 22)
		{
			System.out.println("你可以结婚了");
		}
		else
		{
			System.out.println("先找个富婆包养吧!");
		}

	}
	
}

• Girl.java

package com.atshangguigu.Exer3;

public class Girl {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Girl(String name, int age) {
		
		this.name = name;
		this.age = age;
	}
	public void marry(Boy boy)
	{
		System.out.println("我想嫁给" + boy.getName());
		boy.marry(this);//this是指当前的对象
	}
	/**
	 * 
	*@Description 比较两个对象的大小:
	*@author sky
	*@date 2021年10月18日下午9:06:59
	*@param girl
	*@return 如果返回是一个正数,当前对象大.返回一个负数,当前对象小.返回0,一样大
	 */
	public int compare(Girl girl)
	{
		/*
		if(this.age > girl.age)
		{
			return 1;
		}
		else if(this.age < girl.age)
		{
			return -1;
		}
		else
		{
			return 0;
		}
		*/
		//简化版
		return this.age - girl.age;//this表示的是当前吊用的对象
	}
	
}

• BoyAndGirlTest.java

package com.atshangguigu.Exer3;

public class BoyAndGirlTest {
public static void main(String[] args) {
	Boy boy = new Boy("罗密欧",22);
	boy.shout();
	
	Girl girl = new Girl("朱丽叶",18);
	girl.marry(boy);
	
	Girl girl1 = new Girl("魔法小樱",16);
	System.out.println(girl1.compare(girl));
	if(girl1.compare(girl) > 0)
	{
		System.out.println(girl1.getName() + "年龄大");
	}
	else if(girl1.compare(girl) < 0)
	{
		System.out.println(girl.getName() + "年龄大");
	}
	else 
	{
		System.out.println("二者的年龄一样大");
	}
}
}

56.综合练习1：Account和Customer

57.综合联系2：对象数组

58.package关键字的使用

•  * 一.package关键字的使用
   * 1.为了更好的管理实现项目之中类的管理,提供包的概念
   * 2.使用package声明类或者接口所属的包,声明在源文件的首行(后面会学到xml,现在还不知           道是什么)
   * 3.包是属于标识符,遵循标识符的命名规则与规范以及见名知意.
   * 4.每"."一次就代表一层目录-------这个是需要下Navigator之中进行查看.
   * 补充:同一个包之下不可命名同一个接口或者同一个类.
   *             不同的包之下可以命名同名的接口以及同名的类.
   */

59.MVC设计模式的理解

60.import关键字的使用

• 如果在源文件之中使用了不同包下的同名的类,则至少有一个类需要以全类名的方式进行显示.如下面所示:

 

package com.atshangguigu.Test;
import java.util.*;
import java.util.Arrays;
import java.util.HashMap;
import com.atshangguigu.Test.java3.Dog;

import static java.lang.System.*;
import static java.lang.Math.*;

/*
 * 一.package关键字的使用
 * 1.为了更好的管理实现项目之中类的管理,提供包的概念
 * 2.使用package声明类或者接口所属的包,声明在源文件的首行(后面会学到xml,现在还不知道是什么)
 * 3.包是属于标识符,遵循标识符的命名规则与规范以及见名知意.
 * 4.每"."一次就代表一层目录-------这个是需要下Navigator之中进行查看.
 * 补充:同一个包之下不可命名同一个接口或者同一个类.
 * 	        不同的包之下可以命名同名的接口以及同名的类.
 * 
 * 二.import关键字的使用
 * import:导入
 * 1.在源文件之中显式的使用import结构导入指定包下的类以及接口.
 * 2.声明在包的声明和类的声明之间
 * 3.如果想要导入多个结构,并列写入即可
 * 4.可以使用"xxx.*"的方式,表示导入xxx下面的所有的结构.
 *   导入包下所有的结构使用的是import java.util.*;
 * 5.如果使用的类或者接口是java.lang包下定义的,则可以省略import结构.
 * 6.如果调用的类或者接口是当前的包之下的那么是不报错的,不用导入.
 * 7.如果在源文件之中使用了不同包下的同名的类,则至少有一个类需要以全类名的方式进行显示.
 *   如:com.atshangguigu.java1.PersonTest test = new com.atshangguigu.java1.PersonTest();
	    com.atshangguigu.java2.PersonTest test1 = new com.atshangguigu.java2.PersonTest();
 *   (这样写的方式的可读性是比较差的,实际这样写的方式是思路比较清晰的)
 * 8.如果我们使用"XXX.*"的方式表明可以调用XXX包下的所有结构.但是如果是用XXX包下的下面的结构,那么仍然是需要导入的.
 * 9.import static:导入指定类或者接口中的静态结构.(静态结构后面再讲)
 * 10.import的落脚点可以是类或者接口;
 * 	  import static的落脚点还类或者接口之中的结构.
 */
public class PackageImportTest {
public static void main(String[] args) {
	String info = Arrays.toString(new int[]{1,2,3});
	
	ArrayList list = new Arraylist();
	HashMap map = new HashMap();
	com.atshangguigu.java1.PersonTest test = new com.atshangguigu.java1.PersonTest();
	com.atshangguigu.java2.PersonTest test1 = new com.atshangguigu.java2.PersonTest();
	
	Date date = new Date();
	java.sql.Date data1 = new java.sql.Date(1234567890);
	
	Dog dog = new Dog();
	
	out.println("一会儿得去上英语课,演讲PPT");//import static java.lang.System.*;
	long num = round(123.456);//import static java.lang.Math.*;
}
}

61.每日一考

• 1.构造器的作用是什么?使用的过程中需要注意哪些点?

答:创建对象,初始化对象结构;构造器没有返回值,一个类之中一定会有构造器的

• 2.关于类的属性的赋值,有几种赋值方式.谈一谈赋值的先后顺序

答:默认初始化,构造器之中初始化,对象.属性(对象.方法),给属性赋值

• 3.this关键字可以调用哪些结构?

答:this可以调用属性 方法 构造器,理解为当前对象或者当前正在创建的对象.涉及到形参问题,不可以省略this.

• 4.java之中涉及到了四种权限修饰符,分别是什么?

答:private int age;

     private void eat(){};

• 5.创建Circle类,提供私有的radius属性,提供相应的get和set方法,并且求出相应的圆的面积

答:private double radius;

public void setRadius(double radius )

{

this.radius  = radius;

}

public double getRadius()

{

return radius;

}

public double findArea()

{

return 3.14*getRadius*getRadius;

}