JavaSE面向对象编程上

最新推荐文章于 2022-08-06 22:31:56 发布

天问ㄆ

最新推荐文章于 2022-08-06 22:31:56 发布

阅读量618

点赞数 1

分类专栏： # JavaSE 文章标签： java 编程语言

本文链接：https://blog.csdn.net/dizhi_buyu/article/details/112330536

版权

JavaSE 专栏收录该内容

32 篇文章 9 订阅

订阅专栏

JavaSE面向对象编程上

面向对象编程上
面向过程与面向对象
Java语言的基本元素：类和对象
类的成员之一：属性(field)
类的成员之二：方法(method)
再谈方法
三大特征之一：封装与隐藏
类的成员之三：构造器(构造方法)
关键字：this的使用
关键字：package、import的使用
参考资料

面向对象编程上

学习面向对象内容的三条主线

Java类及类的成员：属性，方法，构造器；代码块，内部类
面向对象的三大特征：封装性，继承性，多态性，(抽象性)
其他关键字：this super static fianl abstract interface package import 等

这些内容贯穿面向对象编程的上中下章节里。

面向过程与面向对象

面向过程(POP Procedure Oriented Programming) 与面向对象(OOP Object Oriented Programming)

二者都是一种思想，面向对象是相对于面向过程而言的
面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做
面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

举例：人把大象装进冰箱里
在这里插入图片描述
面向对象的思想概述

程序员从面向过程的执行者转化成了面向对象的指挥者

面向对象分析方法分析问题的思路和步骤

根据问题需要，选择问题所针对的现实世界中的实体
从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类
把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具

体会以下几个经典案例涉及到的类

人在黑板上画圆类：人黑板
售货员统计收获小票的金额类：售货员小票

Java语言的基本元素：类和对象

类(Class)和对象(Object)是面向对象的核心概念

类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。

可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人
面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计

Java代码世界是由诸多个不同功能的类构成的。常见的类的成员有：

属性：对应类中的成员变量 Field = 属性 = 成员变量
行为：对应类中的成员方法 Method = (成员)方法 = 函数

类和对象的使用

1.创建类设计类的成员
定义类(考虑修饰符，类名)
编写类的属性（考虑修饰符、属性类型、属性名、初始化值）
编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

举例：定义一个关于Person的类

class Person{
    //定义属性 或者 成员变量
	String name;
	int age;
	boolean isMarried;
	
	//定义 行为或者方法
	public void walk(){
		System.out.println("人走路...");
	}
	public String display(){
		return  "名字是" + name + ",年龄是" + age + ",Married = " + isMarried;
	}
}

定义一个关于Student的类

class Student{
	//属性
	String name;
	int age;
	String major;
	String interest;
	
	//行为
	public String say(){
		return "名字是" + name + ",年龄是" + age + ",专业是 = " + major + ",兴趣是" + interest;
	}
}

2.创建类的对象
创建对象语法：类名对象名 = new 类名()

3.通过"对象.属性"和 "对象.方法"调用对象的结构
在这里插入图片描述
注：如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰

举例：(完整的使用这三部做一个简单的演示程序)

package com.atguigu.java;
/*
一 类的设计，其实就是类的成员的设计
	属性 = 成员变量 = field = 域,字段
	方法 = 成员方法 = 函数 = method
	
	创建类的对象 = 类的实例化 = 实例化类 

二 类和对象的使用(面向对象思想落地的实现)
	1.创建类 设计类的成员
	2.创建类的对象
	3.通过 "对象.属性"和 "对象.方法"调用对象的结构
 */
public class PersonTest {
	public static void main(String[] args) {
		//创建person类的对象
		Person p1 = new Person();
		
		//调用对象的结构 属性,方法
		//调用属性： 对象.属性
		p1.name = "tom";
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法  对象.方法
		p1.eat();
		p1.sleep();
		p1.talk("Chinese");
		
		
	}
}

class Person{
	//属性
	String name;
	int age = 1;
	boolean isMale;
	//方法 
	public void eat() {
		System.out.println("人可以吃饭");
	}
	
	public void sleep() {
		System.out.println("人可以睡觉");
	}
	
	public void talk(String language) {
		System.out.println("人可以说话,使用的是：" + language);
	}
}

输出结果
tom
人可以吃饭
人可以睡觉
人可以说话,使用的是：Chinese

对象的内存解析

堆（Heap）：唯一目的就是存放对象实例，所有的对象实例以及数组都要在堆上分配
通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等，局部变量表存放了编译期可知长度的各种基本数据类型，对象引用。方法执行完，自动释放。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

Person p1 = new Person();
在堆中创建一个Person对象，首地址为0x12ab，并将其赋给栈空间中的 p1变量。通过地址值将栈空间的p1指向堆中间的实体。类中的属性存放在实体中，并初始化赋值
p1.name = “Tom”,p1.isMale = “true”
修改属性的值
Person p2 = new Person();
在堆中重新创建一个Person对象，首地址为0x7788，并将其赋给栈空间中的 p2变量。通过地址值将栈空间的p2指向堆中间的实体。类中的属性存放在实体中，并初始化赋值
sysout(p2.name);//null
Person p3 = p1;
栈空间中的变量p3，并将p1中存储的地址值赋给p3,此时p1,p3指向堆中间的同一个实体。
p3.age = 10;
修改堆空间中的属性值
在这里插入图片描述

类的成员之一：属性(field)

语法格式

**修饰符  数据类型· 属性名 = 初始化值;**

属性(成员变量) 和局部变量

相同点

定义变量的格式相同：数据类型变量名 = 变量值;
先声明后使用
变量都有其作用域

不同点

1 在类中声明的位置不同

属性：直接定义在类的一对{}内
局部变量：声明在方法内,方法形参代码块内构造器形参构造器内部的变量

2.关于权限修饰符的不同

属性：可以在声明属性时指明其权限使用权限修饰符，常用的权限修饰符：private,public,缺省,protected -->封装再讲。目前声明属性都使用缺省就可以
局部变量：不可以使用权限修饰符

3.默认初始化值

属性：类的属性根据其类型都有默认初始化值。
整型(byte short int long):0
浮点型(float double):0.0
字符型(char):0
布尔型(boolean):false
引用数据类型(类数组接口)：null
局部变量：没有默认初始化值我们调用
意味着：我们在调用局部变量之前一定要显示赋值
特别地形参在调用时我们赋值即可

4.在内存中加载的位置不同

属性：加载到堆空间中 (非static)
局部变量：加载到栈空间

package com.atguigu.java;
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 = "烙饼";//food 方法内的变量
		System.out.println("北方人喜欢吃" + food);
	}
}

类的成员之二：方法(method)

类中方法的声明和使用:
方法：描述类应该具有等功能

举例：Math类：sqrt() random() Scanner类：nextXxx()

举例
public void eat() {}
public void sleep(int hour) {}
public String getName() {}
public String getNation(String nation) {}

1.方法的分类：按照是否有形参及返回值

	无返回值	有返回值
无形参	void 方法名() {}	返回值的类型方法名(){}
有形参	void 方法名(形参列表) {}	返回值的类型方法名(形参列表){}

2.方法的声明：

权限修饰符返回值类型方法名(形参列表){ 方法体; }

注：static , final , abstract来修饰的方法,后边再说

3.说明

3.1 权限修饰符：默认先使用 public

java规定的4种权限修饰符：private,public,缺省,protected >>封装性再讲

3.2 返回值类型无返回值 vs 有返回值

如果方法有返回值则必须在方法声明时指定返回值的类型同时方法中需要使用return关键字来返回指定类型的变量或者常量
如果方法没有返回值则方法声明时用void表示一般不用return 关键字特例：return; 表示该方法结束
定义方法是否需要返回值？题目要求或者凭经验：具体分析
方法名：属于标识符需要遵循标识符的规则和规范 ,需要见名知意
形参列表：方法可以声明0个 1个或多个形参
格式：数据类型1 形参 1,数据类型2 形参 2;
定义方法时需要不要形参？题目要求凭经验：具体分析
方法体：方法功能的体现

4.return 关键字

适用范围：使用在方法中
作用结束方法或者针对于有返回值类型的方法使用 “return 数据;” 返回需要的数据

注意点: return 关键字后边不能声明执行语句

5.方法的使用

可以调用当前类的属性或方法
方法中不可以定义方法

package com.atguigu.java;
public class CustomerTest1 {

}
//客户类
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;
	}
}

课后练习

1创建一个Person类，其定义如下：
要求：(1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”，调用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。
(2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。

package com.atguigu.exer;

public class Person {
	String name;
	int age;
	/**
	 * sex: 1 表示男性
	 * sex: 0 表示女性
	 */
	int sex;
	
	public void study() {
		System.out.println("studying");
	}
	
	public void showAge() {
		System.out.println("age : " + age);
	}
	
	public int addAge() {
		age += 2;
		return age;
	}
}

package com.atguigu.exer;

public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.name = "tom";
		p1.age = 18;
		p1.sex = 0;
		
		p1.study();
		
		p1.showAge();
		
		int newAge = p1.addAge(2);
		System.out.println(newAge);
		//****************************
		Person p2 = new Person();
		p2.showAge();
		int newAge2 = p2.addAge(10);
	}
}

2.利用面向对象的编程方法，设计类Circle计算圆的面积。

package com.atguigu.exer;

public class CircleTest {
	public static void main(String[] args) {
		Circle c1 = new Circle();
		c1.radius = 5;
		double area = c1.circulateArea();
		System.out.println("圆的面积为" + area);
	}
}

class Circle{
	double radius;
	
	public double circulateArea() {
		return 3.14*radius*radius;
	}
}

3.1 编写程序，声明一个method方法，在方法中打印一个108 的 * 型矩形，在main方法中调用该方法。
3.2 修改上一个程序，在method方法中，除打印一个10 * 8的 * 型矩形外，再计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
3.3 修改上一个程序，在method方法提供 m 和 n 两个参数，方法中打印一个 m * n 的型矩形，并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印

package com.atguigu.exer;

public class Exer3Test {
	public static void main(String[] args) {
		Exer3Test t1 = new Exer3Test();
		t1.method1();
		System.out.println();
		
		System.out.println(t1.method2());
		System.out.println();
		
		System.out.println(t1.method3(3,4));
	}
	
	public void method1(){
		for(int i = 0;i < 10;i++) {
			for(int j = 0;j < 8;j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
	}
	
	public int method2(){
		for(int i = 0;i < 10;i++) {
			for(int j = 0;j < 8;j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
		
		return 10*8;
	}
	
	public int method3(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;
	}
}

4 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：1) 生成随机数：Math.random()，返回值类型double;
2) 四舍五入取整：Math.round(double d)，返回值类型long。

package com.atguigu.exer;

public class Student {
	int number;//学号
	int state;//年级
	int score;//成绩
	
	//显示学生信息
	public void showInfo() {
		System.out.println("number:" + number + ",state:" + state + ",score:" + score);
	}
}

package com.atguigu.exer;

public class StudentTest {
	public static void main(String[] args) {
		//声明一下student类型的数组
		Student[] stus = new Student[20];
		
		for(int i = 0;i < stus.length;i++) {
			//给数组元素赋值
			stus[i] = new Student();
			
			//给Student的属性赋值
			stus[i].number = i + 1;
			//年级 1 - 6
			stus[i].state = (int)(Math.random()*(6 - 1 + 1)) + 1;
			//成绩 0-100
			stus[i].score = (int)(Math.random()*(100 - 0 + 1)) + 0;
		}

		//问题一：打印出3年级(state值为3）的学生信息
		for(int i = 0;i < stus.length;i++) {
			if(stus[i].state == 3) {
				stus[i].showInfo();
			}
		}
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		for(int i = 0;i < stus.length;i++) {
			for(int j = 0;j < stus.length - 1 - i;j++) {
				if(stus[j].score > stus[j + 1].score ) {
					//如果需要交换  交换的是数组元素:Student对象
					Student temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
		
		//展示学生信息
		for(int i = 0;i < stus.length;i++) {
			stus[i].showInfo();
		}

	}
}

优化上述代码，将操作数据的功能封装到函数中

package com.atguigu.exer;

public class Student {
	int number;//学号
	int state;//年级
	int score;//成绩
	
	//显示学生信息
	public void showInfo() {
		System.out.println("number:" + number + ",state:" + state + ",score:" + score);
	}
	
}

package com.atguigu.exer;

public class StudentTest {
	public static void main(String[] args) {
		//声明一下student类型的数组
		Student[] stus = new Student[20];
		
		for(int i = 0;i < stus.length;i++) {
			//给数组元素赋值
			stus[i] = new Student();
			
			//给Student的属性赋值
			stus[i].number = i + 1;
			//年级 1 - 6
			stus[i].state = (int)(Math.random()*(6 - 1 + 1)) + 1;
			//成绩 0-100
			stus[i].score = (int)(Math.random()*(100 - 0 + 1)) + 0;
		}
		
		
		StudentTest test = new StudentTest();
		//问题一：打印出3年级(state值为3）的学生信息
		test.searchState(stus,3);
		System.out.println("//*******************");
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		test.sort(stus);
		test.print(stus);
		
		

	}
	/**
	 * 遍历数组信息
	 * @param stus ：需要遍历的数组
	 */
	public void print(Student[] stus) {
		for(int i = 0;i < stus.length;i++) {
			stus[i].showInfo();
			}
	}
	
	/**
	 * 查找Student数组中指定年级的学生信息
	 * @param stus  : 指定数组
	 * @param state ： 需要查找的年级
	 */
	public void searchState(Student[] stus,int state) {
		for(int i = 0;i < stus.length;i++) {
			if(stus[i].state == state) {
				stus[i].showInfo();
			}
		}	
	}
	
	/**
	 * 对Student数组按照成绩进行排序
	 * @param stus 
	 */
	public void sort(Student[] stus) {
		for(int i = 0;i < stus.length;i++) {
			for(int j = 0;j < stus.length - 1 - i;j++) {
				if(stus[j].score > stus[j + 1].score ) {
					//如果需要交换  交换的是数组元素:Student对象
					Student temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}	
	}
	
}

注意几个点

一理解"万事万物皆对象"

在Java语言范畴中，我们都将功能，结构等等封装到类中，通过类的实例化，来调用具体的功能机构
涉及到Java语言与前端Html，后端的数据库交互时，前后端的结构在Java层面交互时都体现为类，对象

二内存解析的说明

引用数据类型的变量，只可能存储两类值：null 或地址值(含变量的类型)

三匿名对象

理解：我们创建的对象，没有显式的赋给一个变量名，即为匿名对象
特征：正常情况下，匿名对象只能调用一次

再谈方法

方法的重载(overload)

概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可
特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
理解特点：两同一不同：同一个类同一个方法名参数列表不同(参数个数不同或者参数类型不同)
举例：
//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}
判断是否重载
跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系
在通过对象调用算法时，通过方法名和参数列表确定一个指定的方法
练习

第一个 与void show(int a,char b,double c){}构成重载的有：
a) void show(int x,char y,double z){} // no
b) int show(int a,double c,char b){} // yes
c) void show(int a,double c,char b){} // yes
d) boolean show(int c,char b){} // yes
e) void show(double c){} // yes
f) double show(int x,char y,double z){} // no
g) void shows(){double c} // no

第二个编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的main ()方法中分别用参数区别调用三个方法。

package com.atguigu.exer;

public class OverLoadTest {
	
	
	public void mOL(int i) {
		System.out.println(i*i);
	}
	
	public void mOL(int a,int b) {
		System.out.println(a*b);
	}
	
	public void mOL(String name) {
		System.out.println(name);
	}
}

package com.atguigu.exer;

public class OverLoadTest {
	
public int max(int a,int b) {
		return (a>b)?a:b;
	}
	
	public double max(double i,double j) {
		return (i>j)?i:j;
	}
	
	public double max(double i,double j,double k) {
		double temp = (i>j)?i:j;
		return (temp>k)?temp:k;
	}
}

可变个数的形参

jdk 5.0新增的内容
格式：数据类型 … 变量名
当调用可变个数形参的方法时，传入的参数可以是：0个 1个 2个，，
可变个数形参的方法与本类中方法名相同，形参不同的方法构成重载
可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间的不构成重载 public void show(String … args) 等价于 public void show(String [] args)
可变个数形参在方法的形参中，必须声明在末尾
可变个数形参在方法的形参中，最多只能声明一个

方法参数的值传递机制

关于变量的赋值

如果变量是基本数据类型，此时赋值的是变量所保存的的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

方法的形参的传递机制：值传递

形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
值传递机制(将实参的值赋给形参)
如果变量是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。

package com.atguigu.exer;

public class ValueTransfer {
	public static void main(String[] args) {
		
		ValueTransfer  v1 = new ValueTransfer();
		int m = 10;
		int n = 20;
		System.out.println("交换前");
		System.out.println("m = " + m + ",n = " + n);
		v1.swap(m, n);
		System.out.println("交换后");
		System.out.println("m = " + m + ",n = " + n);
	}
	
	public void swap(int m,int n) {
		int temp = m;
		m = n;
		n = temp;
		
	}
}

交换前
m = 10,n = 20
交换后
m = 10,n = 20

分析原因：画对象内存解析
swap()方法中交换了传递给形参的m,n值之后，就出栈了，所以main()方法中的m,n数值并没有发生变化
在这里插入图片描述
如果是引用数据类型，此时实参赋给形参的是实参存储数据的地址值

package com.atguigu.exer;

public class ValueTransferTest2 {
	public static void main(String[] args) {
		Data  data = new Data();
		
		data.m = 10;
		data.n = 20;
		System.out.println("交换前");
		System.out.println("m = " + data.m + ",n = " + data.n);
		ValueTransferTest2 test = new ValueTransferTest2();
		test.swap(data);
		System.out.println("交换后");
		System.out.println("m = " + data.m + ",n = " + data.n);
	}
	
	public void swap(Data data) {
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
}

class Data{
	int m;
	int n;
}

交换前
m = 10,n = 20
交换后
m = 20,n = 10

对象内存解析结构
在这里插入图片描述

值传递机制练习

15 0
20
内存解析结构如下

定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。

//错误写法
for(int i= 0；i < arr.length;i++){
	arr[i] = arr[i] / arr[0];
}//首位置的值在第一次运行时就被改变了
//正确写法1
for(int i = arr.length – 1;i >= 0;i--){
	arr[i] = arr[i] / arr[0];
}
//正确写法2
int temp = arr[0];
for(int i= 0；i < arr.length;i++){
	arr[i] = arr[i] / temp;
}

给出下列程序输出结果

int[] array1 = new int[]{1,2,3};
System.out.println(array1);//地址值

char[] array2 = new char[]{'a','b','c'};
System.out.println(array2);//abc

练习6：将对象作为参数传递给方法
（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积。

package com.atguigu.exer;

public class Circle1 {
	double radius;
	
	public double findArea() {
		return Math.PI *radius*radius;
	}
}

（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time)在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
（3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示

package com.atguigu.exer;

public class PassObject1 {
	public static void main(String[] args) {
		
		PassObject1 test = new PassObject1();
		Circle1 c = new Circle1();
		
		test.printAreas(c,5);
		
		System.out.println("now radius is " + c.radius);
	}

	public void printAreas(Circle1 c,int time) {
		System.out.println("Radius\t\tArea");
		for(int i = 0; i <= time;i++) {
			//设置圆的半径
			c.radius = i;
			System.out.println(c.radius + "\t\t" + c.findArea());
			
		}
		
		c.radius = time + 1;
	}
}

递归(recursion)方法 (了解)

递归方法：一个方法体内调用它自身
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环
举例
1.计算1-100之间所有自然数的和

public int getSum(int n) {
		if(n == 1) {
			return 1;
		}else {
			return n + getSum(n-1);
		}
	}

2.请用Java写出递归求阶乘(n!)的算法

public int getFactorial(int n) {
		if(n == 1) {
			return 1;
		}else {
			return n*getFactorial(n-1);
		}
	}

3.已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0的整数，求f(10)的值

public int getArrayValue(int n) {
		if(n == 0) {
			return 1;
		}else if(n == 1) {
			return 4;
		}else {
			return 2*getArrayValue(n-1)+getArrayValue(n-2);
		}
	}

4.输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值

public int getArrayValue(int n) {
		if(n == 1) {
			return 1;
		}else if(n == 2) {
			return 1;
		}else {
			return getArrayValue(n-1)+getArrayValue(n-2);
		}
	}

三大特征之一：封装与隐藏

程序设计追求“高内聚，低耦合”
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅对外暴露少量的方法用于使用
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗地讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想
问题引入：当我们创建一个类的对象以后，通过"对象.属性"的方式对对象的属性进行赋值。赋值操作受到属性的数据类型和存储范围的制约。除此之外没有其他的限制条件。但是，在实际问题中往往需要给属性赋值的同时加入额外的限制条件。这些条件不能在属性声明时体现，只能通过方法进行限制条件的添加。同时，避免用户使用"对象.属性"的方式对属性进行赋值，需要将属性声明为私有的(private)
此时，针对属性就体现了封装性
封装性的体现之一
将类的属性xxx私有化(private)，同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

package com.atguigu.exer;

public class AnimalTest {
public static void main(String[] args) {
	
	Animal a = new Animal();
	a.name = "大黄";
	a.age = 1;

	a.setlegs(4);
	a.show();
}
	
}

class Animal{
	String name;
	int age;
	private int legs;//腿的个数
	
	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);
	}
}

封装性的体现需要权限修饰符
java规定的4种权限修饰符：private 缺省 protected public,

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	Yes
缺省	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

4种权限可以用来修饰类及类的内部结构：属性，方法，构造器，内部类
注：修饰类的话只能使用缺省和 public

java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性大小
举例创建程序,在其中定义两个类：Person和PersonTest类。定义如下：用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。在 PersonTest 类中实例化 Person 类的对象 b ，调用 setAge() 和getAge()方法，体会Java的封装性。

package com.atguigu.exer;

public class Person1 {
	private int age;
	
	public void setAge(int i) {
		if(i < 0 || i > 130) {
			System.out.println("传入数据有误");	
		}else {
			age = i;
		}
	}
	
	public int getAge() {
		return age;
	}
}

package com.atguigu.exer;

public class PersonTest1 {
	public static void main(String[] args) {
		Person1 p1 = new Person1();
		
		//p1.age = 10;The field Person1.age is not visible
		
		p1.setAge(12);
		int newAge = p1.getAge();
		
		System.out.println("newAge = " + newAge);
	}
	
}

类的成员之三：构造器(构造方法)

构造器的作用
创造对象：new + 构造器 Order o = new Order();
初始化对象的属性 Person p = new Person(“Peter”,15);
说明
如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
定义构造器的格式：权限修饰符类名(形参列表){}
一个类中定义的多个构造器，彼此构成重载
一旦我们显式定义了类的构造器之后，系统就不再提供默认的空参构造器
一个类中，至少会有一个构造器

- 练习
在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18
修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值

package com.atguigu.exer;

public class Person1 {
	private int age;
	
	public Person1() {
		age = 18;
	}
	
	public void setAge(int i) {
		if(i < 0 || i > 130) {
			System.out.println("传入数据有误");
			
		}else {
			age = i;
		}
	}
	
	public int getAge() {
		return age;
	}
}

package com.atguigu.exer;

public class Person1 {
	private int age;
	private String name;
	
	public Person1(String n,int a){
		name = n;
		age = a;
	}
	
	public void setAge(int i) {
		if(i < 0 || i > 130) {
			System.out.println("传入数据有误");
			
		}else {
			age = i;
		}
	}
	
	public int getAge() {
		return age;
	}
}

编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积

package com.atguigu.exer;

public class TriAngle {
	private double base;
	private double height;
	
	public TriAngle() {
		
	}
	
	public TriAngle(double b,double h) {
		base = b;
		height = h;
	}

	
	public void setBase(double b) {
		base = b;
	}
	
	public double getBase() {
		return base;
	}
	
	public void setHeight(double h) {
		height = h;
	}
	
	public double getHeight() {
		return height;
	}
}

package com.atguigu.exer;

public class TriAngleTest {
	public static void main(String[] args) {
		TriAngle t1 = new TriAngle();
		t1.setBase(2.4);
		t1.setHeight(3.0);
		
		System.out.println("base = " + t1.getBase() + ",height = " + t1.getHeight());
		
		TriAngle t2 = new TriAngle(3.0,4.5);
		System.out.println("base = " + t2.getBase() + ",height = " + t2.getHeight());
	}
}

总结属性赋值的先后顺序

默认初始化
显式初始化
构造器中初始化
通过"对象.属性"或者"对象.方法"的方式赋值

拓展知识：JavaBean

JavaBean是一种Java语言写成的可重用组件
所谓javaBean，是指符合如下标准的Java类
类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法

拓展知识：UML类图
在这里插入图片描述

+ 表示 public 类型， - 表示 private 类型，#表示protected类型
方法的写法:方法的类型(+、-) 方法名(参数名：参数类型)：返回值类型

关键字：this的使用

学习任意知识点都可以根据3W原则去理解：What(它是什么)，Why(为什么会出现它)，How(它如何来使用)

this关键字的使用

this可以用来修饰或调用：属性，方法，构造器
this修饰属性和方法：
this理解为当前对象或当前正在创造的属性
在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法，通常情况下我们都选择省略"this"。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此属性是变量，而非形参
在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创造的对象属性或方法，通常情况下我们都选择省略"this"。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此属性是变量，而非形参
this 调用构造器
我们在类的构造器中，可以显示的使用"this(形参列表)"方式，调用本类中指定的其他构造器
构造器不能通过 "this(形参列表)"方式调用自己
如果一个类中有n个构造器，则最多有n-1个构造器中使用了 “this(形参列表)”
规定："this(形参列表)"必须声明在当前构造器中的首行
构造器内部，最多只能声明一个"this(形参列表)"方式

package com.atguigu.exer;

public class ThisTest {
	public static void main(String[] args) {
		Exer p2 = new Exer("jack",20);
		System.out.println("It's ok");
	}
}

class Exer{
	private String name;
	private int age;
	
	public Exer() {
		this.eat();
		System.out.println("每个构造器都需要去做的事情！");
	}
	public Exer(String name) {
		this();
		this.name = name;
	}
	public Exer(int age) {
		this();
		this.age = age;
	}
	public Exer(String name,int age) {
		this(age);
		this.name = name;
		//this.age = 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 eat() {
		System.out.println("人吃饭");
		this.study();
	}
	
	public void study() {
		System.out.println("人学习");
	}
}

练习

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("再等等~");
		}
	}
	
}

class Girl{
	private String name;
	private int age;
	
	public Girl() {
		
	}
	public Girl(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public void marry(Boy boy) {
		System.out.println("我想嫁给" + boy.getName());
		boy.marry(this);
	}
	/**
	 * 
	 * @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;
		}
	}
}

package com.atguigu.exer;

public class BoyGirl {
	public static void main(String[] args) {
		Boy boy = new Boy("罗密欧",21);
		boy.shout();
		
		Girl girl = new Girl("朱丽叶",18);
		girl.marry(boy);
		
		Girl girl1 = new Girl("祝英台",20);
		int result = girl.compare(girl1);
		System.out.println(result);
	}
}

实验1：Account_Customer.doc

package com.atguigu.exer;

public class Account {
	private int id;//账号
	private double balance;//余额
	private double annualInterestRate;//年利率
	
	public Account(int id, double balance, double annualInterestRate) {
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public double getAnnualInterestRate() {
		return annualInterestRate;
	}

	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}
	//取钱
	public void withdraw (double amount) {
		if(this.balance < amount) {
			System.out.println("余额不足,取款失败");
			return;
		}
		
		this.balance -= amount;
		System.out.println("成功取出" + amount);
	}
	//存钱
	public void deposit (double amount) {
		if(amount > 0) {
			this.balance += amount;
			System.out.println("成功存入" + amount);
		}
	}
}

package com.atguigu.exer;

public class Customer {
	private String firstName;
	private String lastName;
	private Account account;
	
	public Customer(String f,String l) {
		this.firstName = f;
		this.lastName = l;
	}
	
	public String getFirstName() {
		return this.firstName;
	}
	
	public String getLastName() {
		return this.lastName;
	}
	
	public Account getAccount() {
		return this.account;
	}
	
	public void setAccount(Account account) {
		this.account = account;
	}
}

package com.atguigu.exer;

public class CustomerTest {
	public static void main(String[] args) {
		Customer cust = new Customer("Jane", "Smith");
		
		Account acct = new Account(1000, 2000, 0.0123);
		
		cust.setAccount(acct);
		
		cust.getAccount().deposit(100);
		cust.getAccount().withdraw(960);
		cust.getAccount().withdraw(2000);
		
		System.out.println("Customer [" + cust.getLastName()+", " +  cust.getFirstName() +"] "+
				 "has a account: id is" + cust.getAccount().getId() + 
				 ", annualInterestRate is " + cust.getAccount().getAnnualInterestRate()*100 +
				 "%, balance is " + cust.getAccount().getBalance());
	}
}

实验2：Account_Customer_Bank.doc

package com.atguigu.exer2;
/**
 * @author dell
 * 2021年1月10日
 * @vresion: jdk 1.8
 * @Description:
 */
public class Account {
	private double balance;
	
	public  Account(double init_balabce) {
		this.balance = init_balabce;
	}
	
	public double getBalabce() {
		return this.balance;
	}
	
	/**
	 * 2021年1月10日
	 * @Description :  存钱
	 * @param amt  存入的金额
	 */
	public void deposit(double amt) {
		if(amt > 0) {
			this.balance += amt;
			System.out.println("成功存入 :" + amt);
		}
	}
	
	/**
	 * 2021年1月10日
	 * @Description : 取钱
	 * @param amt 取钱的金额
	 */
	public void withdraw(double amt) {
		if( this.balance > amt) {
			this.balance -= amt;
			System.out.println("成功取出：" + amt);
			
		}else {
			System.out.println("您的余额不足！");
		}
		
	}
}

package com.atguigu.exer2;

public class Customer {
	private String firstName;
	private String laseName;
	private Account account;
	
	public Customer(String f,String l) {
		this.firstName = f;
		this.laseName = l;
	}
	
	public String getFirstName() {
		return this.firstName;
	}
	
	public String getLastName() {
		return this.laseName;
	}
	
	public Account getAccount() {
		return this.account;
	}
	
	public void setAccount(Account acct) {
		this.account = acct;
	}
}

package com.atguigu.exer2;

public class Bank {
	private Customer[] customers;//存放多个客户的数组
	private int numberOfCustomer;//记录客户的个数
	
	public Bank() {
		customers = new Customer[10];
	}
	/**
	 * 2021年1月10日
	 * @Description : 添加客户
	 * @param f 客户的姓
	 * @param l 客户的名
	 */
	public void addCustomer(String f,String l) {
		Customer cust = new Customer(f,l);
		customers[numberOfCustomer] = cust;
		numberOfCustomer++;
	}
	/**
	 * 2021年1月10日
	 * @Description : 获取客户的个数
	 * @return  客户个数
	 */
	public int getNumberOfCunstomer() {
		return numberOfCustomer;
	}
	/**
	 * 2021年1月10日
	 * @Description : 获取指定位置的客户信息
	 * @param index  指定位置
	 * @return  客户
	 */
	public Customer getCustomer(int index) {
		if(index >= 0 && index < numberOfCustomer) {
			return customers[index-1];
		}
		
		return null;
	}
}

package com.atguigu.exer2;

/**@author dell
 * 2021年1月10日
 * @vresion: jdk 1.8
 * @Description: Account Customer Bank 的测试类
 */
public class BankTest {
	public static void main(String[] args) {
		Bank bank = new Bank();
		
		bank.addCustomer("Jane", "smith");
		
		bank.getCustomer(0).setAccount(new Account(2000));
		bank.getCustomer(0).getAccount().deposit(500);
		bank.getCustomer(0).getAccount().withdraw(600);
		double remainMoney = bank.getCustomer(0).getAccount().getBalabce();
		
	}

关键字：package、import的使用

package关键字的使用

为了更好地实现项目中类的管理，提供包的概念
使用package声明类或者接口所属的包，声明在源文件的首行
包，属于标识符，遵循标识符的命名规则，规范(xxxyyyzzz)，“见名知意”
每出现 "."一次，就代表一层文件结构
补充：同一个包下，不可以命名同名的类，接口。不同的包下，可以命名同名的类，接口。

MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。
这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。
举例：

import关键字的使用
在源文件中显式的使用import结构导入指定包下的类，接口。
声明在包的声明和类的声明之间
如果需要导入多个结构，则并列写出即可
可以使用" xxx.* "的方式，表示可以导入xxx所属下的所有结构
如果使用的类或接口是在java.long包下定义的，或者是当前包下的，则可以省略import结构
如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类
如果已经使用" xxx.* "的方式导入xxx包下的类。那么如果需要使用xxx包的子包下的类的话，仍然需要显式导入
import static组合的使用：调用指定类或接口下的静态的属性或方法

参考资料

尚硅谷-Java零基础教程

这一节内容可真多，

天问ㄆ

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
JavaSE面向对象编程上

JavaSE面向对象编程上面向对象编程上面向过程与面向对象Java语言的基本元素：类和对象面向对象编程上学习面向对象内容的三条主线Java类及类的成员：属性，方法，构造器；代码块，内部类面向对象的三大特征：封装性，继承性，多态性，(抽象性)其他关键字：this super static fianl abstract interface package import 等这些内容贯穿面向对象编程的上中下章节里。面向过程与面向对象面向过程(POP Procedure Oriented
复制链接

扫一扫