学习面向对象内容的三条主线
1.Java类及类的成员
属性，方法，构造器，代码块，内部块
2.面向对象的三大特征
封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)
（抽象性）
3.其它关键字
this,super,static,final等关键字的使用
面向过程(POP) 与 面向对象(OOP)
二者都是一种思想，面向对象是相对于面向过程而言的。面向过程， 强调的是功能行为，以函数为最小单位，考虑怎么做。 面向对象，将功能封装进对象， 强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
Java语言的基本元素：类和对象
面向对象的思想概述
类(Class)和对象(Object)是面向对象的核心概念。
类是对一类事物的描述，是抽象的、概念上的定义。
对象是实际存在的该类事物的每个个体，因而也称为实(instance)。
“万事万物皆对象”。
例如Java程序开发过程中，Scanner类中对象的实例化。
面向对象程序设计的重点是类的设计
类的设计， 其实就是类的成员的设计
常见的类的成员有：
属 性：对应类中的成员变量
行 为：对应类中的成员方法
java类的实例化，即创建类的对象
4.类和对象的使用（面向对象思想落地的实现）
》创建类。设计类的成员
》创建类的对象（类的实例化）
》通过“对象.属性”和“对象.方法”调用对象的结构
下面展示一些 PersonTest。
package ToObject;
/**
* @author dell
* @version 11.0
* @Classname PersonTest
* @Description Do
* @date 2021/7/7 10:06
* @Project Java2018
**/
public class PersonTest {
public static void main(String[] args) {
//创建类的对象
Person p1 = new Person();
//类似于Scanner scanner = new Scanner(System in);
//调用对象的结构、属性、对象
//调用属性：“对象.属性"
p1.name = "Tom";
p1.age = 12;
p1.isMale = true;
System.out.println("该同学的姓名是：" + p1.name);
//调用方法：“对象.方法”
p1.eat();
p1.sleep();
p1.talk("chinese");
//*******************/**
Person p2 = new Person();
System.out.println(p2.name);//nall
System.out.println(p2.isMale);//false
//将p1的变量的对象地址值赋给p3，导致p1和p3都指向堆空间的统一个对象实体。
Person p3 = p1;
System.out.println(p3.name);//Tom
p3.age = 29;//p1和p3共用一个地址值，改变p3就是改变p1
System.out.println(p1.age);//29
}
}
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){//language是形参，也是局部变量
System.out.println("人可以说话，使用的是：" + language);
}
}
5.如果创建一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）意味着让我们修改一个类的属性，不会影响另外属性的值。
6.对象的创建和使用：内存解析
堆（ Heap） ， 此内存区域的唯一目的就是存放对象实例， 几乎所有的对象实例都在这里分配内存。 这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
通常所说的栈（ Stack） ， 是指虚拟机栈。 虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（ boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（ reference类型，它不等同于对象本身， 是对象在堆内存的首地址）。方法执行完， 自动释放。
方法区（Method Area） ， 用于存储已被虚拟机加载的类信息、 常量、 静态变量、 即时编译器编译后的代码等数据。（方法中都是局部变量）
类中属性的使用
1.语法格式：
修饰符 数据类型 属性名 = 初始化值 ;
说明1: 修饰符
常用的权限修饰符有： private、缺省、 protected、 public
其他修饰符： static、 final (暂不考虑)
说明2：数据类型
任何基本数据类型(如int、 Boolean) 或 任何引用数据类型。
说明3：属性名
属于标识符，符合命名规则和规范即可。
2.举例：
public class Person{
private int age; //声明private变量 age
public String name = “Lila”; //声明public变量 name
}
3.变量的分类：成员变量与局部变量
在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
注意：二者在初始化值方面的异同:
同： 都有生命周期
异： 局部变量除形参外，均需显式初始化。
4.成员变量（属性）和局部变量的区别
相同点：
定义变量的格式：数据类型 变量名 = 变量值
先声明，后使用
变量都由对应的作用域
不同点：
在类中声明的位置不同
属性直接定义在类的一对{}中；局部变量声明在方法内，方法形参、代码块内，构造器形参，构造器内部变量
关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected — 》封装性
局部变量:不可以使用权限修饰符。
默认初始化值的情况下
属性：类的属性，根据其类型，都有默认初始化值。
整型（byte、short、int、long），0
浮点型（float、double），0.0
字符型（char），0（或‘\u0000’）
布尔型（boolean），false
局部变量：没有默认初始化值。
意味着我们在调用局部变量之前，一定要显示赋值。特别地：形参在调用时，赋值即可。
在内存中加载的位置：
属性：加载到堆空间中，（非static）
局部变量：加载到栈空间。
5.对象属性的默认初始化赋值
当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person及前面讲过的数组。
类中方法的声明和使用
方法(method、函数):
方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
将功能封装为方法的目的是，可以实现代码重用，简化代码
Java里的方法不能独立存在，所有的方法必须定义在类里。
方法的声明格式：（可有形参可没有）
权限修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码
return 返回值;
｝
其中：修饰符： public,缺省,private, protected等，static、final、abstract来修饰的方法后面再讲。
说明：
1、权限修饰符 （默认使用public）
java规定的4种权限修饰符，private、public、缺省、protected
2、返回值类型
如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中必须要使用return关键字来指定类型的变量或常量。
如果方法没有返回值，则方法声明时，使用void表示则通常没有返回值，一般不使用return，但如果使用的话只能以“return；”表示结束此方法，return后续的代码不再执行。
返回值类型：
没有返回值： void。
有返回值，声明出返回值的类型。与方法体中“return 返回值” 搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据。
3、方法名：属于标识符，遵循标识符的规范，见名知意。
4、形参列表：方法可以声明0个，1个或者多个形参
格式：数据类型1 形参1，。。。。
5、方法体：方法功能的实现。
return关键字的使用
1.使用范围：使用在方法体中
2.作用：结束方法
针对返回值类型的方法，使用“return数据”方法返回所要的数据
3.注意点：return关键字后面不可以声明执行语句。
6、方法的使用，可以调用当前类的属性和方法。（特殊：方法A中调用方法A：递归方法）
方法中不可以重新定义一个方法。
方法的分类：按照是否有形参及返回值
举例：public void eat（）{} void类型没有形参
public void sleep（int huor）{} void类型有形参
public String getName（）{} 非void类型没有形参，方法体中“return 返回值”
public String getName（String nation）{} void类型有形参,方法体中“return 返回值”
方法的调用
方法通过方法名被调用，且只有被调用才会执行。
注 意：
方法被调用一次，就会执行一次
没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
定义方法时，方法的结果应该返回给调用者，交由调用者处理。
方法中只能调用方法或属性， 不可以在方法内部定义方法。
练习：
下面展示一些 PersonTest1。
// A code block
package ToObject;
/**
* @author dell
* @version 11.0
* @Classname PersonTest1
* @Description Do
* @date 2021/7/7 10:46
* @Project Java2018
**/
/*
创建一个Person类， 其定义如下：
name:String
age:int
sex:int
+study():void
+showAge():void
+addAge(int i):int
要求： (1)创建Person类的对象，设置该对象的name、
age和sex属性，调用study方法，输出字符串
“studying”，调用showAge()方法显示age值，调用
addAge()方法给对象的age属性值增加2岁。
(2)创建第二个对象，执行上述操作，体会同一个类的
不同对象之间的关系。
*/
public class PersonTest1 {
public static void main(String[] args) {
PersonNew p1 = new PersonNew();
p1.age = 19;
p1.name = "Tom";
p1.sex = 1;
p1.study();
p1.showAge();
int newAge = p1.addAge(2);
System.out.println("新年龄是：" + newAge);
}
}
class PersonNew{
String name;
int age;
int sex;//男性为1，女性为0
public void study(){
System.out.println("Studying");
}
public void showAge(){
System.out.println(age);
}
public int addAge(int i){
age += i;
return age;
}
}
2.利用面向对象的编程方法，设计类Circle计算圆的面积。
下面展示一些 Circle。
package ToObject;
/**
* @author dell
* @version 11.0
* @Classname Circle
* @Description Do
* @date 2021/7/7 14:26
* @Project Java2018
**/
/*
利用面向对象的编程方法，设计类Circle计算圆的面积。
*/
public class Circle {
public static void main(String[] args) {
CircleArea c1 = new CircleArea();
c1.radius = 2.1;
// //针对方式一
// double area = c1.findArea();
// System.out.println("圆的面积是：" + area);
//针对方式二
c1.findArea();
}
}
class CircleArea{
//属性
double radius;
// //方式一：
// public double findArea(){
// double area = Math.PI * radius * radius;
// return area;
//
// }
//方式二：
public void findArea(){
double area = Math.PI * radius * radius;
System.out.println("圆的面积为：" + area);
}
}
练习3
3.1 编写程序， 声明一个method方法， 在方法中打印一个108 的型矩形，在main方法中调用该方法。
3.2 修改上一个程序， 在method方法中， 除打印一个108的型矩形外， 再计算该矩形的面积， 并将其作为方法返回值。 在main方法中调用该方法，接收返回的面积值并打印。
3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个mn的型矩形，并计算该矩形的面积， 将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
下面展示一些 MethodTest。
package ToObject;
/**
* @author dell
* @version 11.0
* @ClassnameMethodTest
* @Description Do
* @date 2021/7/7 14:43
* @Project Java2018
**/
/*
3.1 编写程序， 声明一个method方法， 在方法中打印一个10*8 的*型矩形，在main方法中调用该方法。
3.2 修改上一个程序， 在method方法中， 除打印一个10*8的*型矩形外， 再计算该矩形的面积，
并将其作为方法返回值。 在main方法中调用该方法，接收返回的面积值并打印。
3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，并计算该矩形的面积，
将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
*/
public class MethodTest {
public static void main(String[] args) {
Method m1 = new Method();
// //对应3.1
// m1.rectangleArea();
// //对应3.2
// int area = m1.rectangleArea();
// System.out.println("矩形的面积为：" + area);
//对应3.3
// m1.m = 12;
// m1.n = 11;
int area = m1.rectangleArea(12,11);
System.out.println("矩形的面积为：" + area);
}
}
class Method{
// //3.1
// public void rectangleArea(){
// for (int i = 0;i < 10;i++){
// for (int j = 0;j < 8;j++){
// System.out.print("* ");
// }
// System.out.println();
// }
// }
// //3.2
// public int rectangleArea(){
// for (int i = 0;i < 10;i++){
// for (int j = 0;j < 8;j++){
// System.out.print("* ");
// }
// System.out.println();
// }
//
// return 10 * 8;
// }
//3.3
// int m;
// int n;
public int rectangleArea(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;
}
}
- 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
- 生成随机数： Math.random()，返回值类型double;
- 四舍五入取整： Math.round(double d)，返回值类型long。
下面展示一些StudentArray。
package ToObject;
/**
* @author dell
* @version 11.0
* @ClassnameArray
* @Description Do
* @date 2021/7/7 15:07
* @Project Java2018
**/
/*
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
1) 生成随机数： Math.random()，返回值类型double;
2) 四舍五入取整： Math.round(double d)，返回值类型long。
*/
import java.util.Scanner;
public class StudentArray {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("输入学生数：");
int m = scanner.nextInt();
//声明Student类型的数组
Student[] data = new Student[m];
System.out.println("学号" + "\t" + "年级" + "\t" + "成绩" );
for (int i = 0;i < data.length;i++){
//给数组元素进行赋值
data[i] = new Student();
//给Student对象的属性赋值
//学号从1开始
data[i].number = i + 1;
//年级是1到6年级
data[i].state = (int)(Math.random() * (6 - 1 + 1) - 1);
//分数是1到100
data[i].score = (int)(Math.random() * (100 - 0 + 1) );
}
//遍历数组，进行检测
for (int i = 0;i < data.length;i++){
System.out.println(data[i].infor());
}
//问题一：打印出3年级(state值为3）的学生信息。
System.out.println("............................");
for(int i = 0;i < data.length;i++){
if (data[i].state == 3){
System.out.println(data[i].infor());
}
}
System.out.println("............................");
//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
for (int i = 0;i < data.length - 1;i++){
for (int j = 0;j < data.length - 1 - i;j++){
if (data[j].score > data[j + 1].score){
//如果需要换序，交换的是数组的元素，Student的对象
Student temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
for (int i = 0;i < data.length;i++){
System.out.println(data[i].infor());
}
}
}
class Student{
int number;//学号
int state;//年级
int score;//成绩
public String infor(){
return "学号:" + number + "年级:" + state + "成绩:" + score;
}
}
下面展示一些 StudentTest1。
package ToObject;
import java.util.Scanner;
/**
* @author dell
* @version 11.0
* @ClassnameStudentTest1
* @Description Do
* @date 2021/7/7 16:24
* @Project Java2018
**/
/*
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
1) 生成随机数： Math.random()，返回值类型double;
2) 四舍五入取整： Math.round(double d)，返回值类型long。
*/
//进行封装优化
public class StudentTest1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("输入学生数：");
int m = scanner.nextInt();
Student1[] data = new Student1[m];
System.out.println("学号" + "\t" + "年级" + "\t" + "成绩" );
for (int i = 0;i < data.length;i++){
//给数组元素进行赋值
data[i] = new Student1();
//给Student对象的属性赋值
//学号从1开始
data[i].number = i + 1;
//年级是1到6年级
data[i].state = (int)(Math.random() * (6 - 1 + 1) - 1);
//分数是1到100
data[i].score = (int)(Math.random() * (100 - 0 + 1) );
}
//从StudentTest1类中调用print、sort、searchState等对象
StudentTest1 test = new StudentTest1();
//遍历数组，进行检测
// for (int i = 0;i < data.length;i++){
// System.out.println(data[i].number + "\t" + data[i].state + "\t" + data[i].score);
// }
test.print(data);
//问题一：打印出3年级(state值为3）的学生信息。
System.out.println("............................");
test.searchState(data,4);
System.out.println("............................");
//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
test.sort(data);
//对冒泡排序后的结果进行遍历
// for (int i = 0;i < data.length;i++){
// System.out.println(data[i].infor());
// }
test.print(data);
}
public void print(Student1[] data) {
for (int i = 0;i < data.length;i++){
System.out.println(data[i].infor());
}
}
public void searchState(Student1[] data,int state){
for(int i = 0;i < data.length;i++){
if (data[i].state == state){
System.out.println(data[i].infor());
}
}
}
public void sort(Student1[] data){
for (int i = 0;i < data.length - 1;i++){
for (int j = 0;j < data.length - 1 - i;j++){
if (data[j].score > data[j + 1].score){
//如果需要换序，交换的是数组的元素，Student的对象
Student1 temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
}
}
class Student1{
int number;//学号
int state;//年级
int score;//成绩
public String infor(){
return "学号:" + number + "年级:" + state + "成绩:" + score;
}
}
5.声明一个日期类型MyDate：有属性：年year,月month，日day。 创建2个日期对象，分别赋值为：你的出生日期，你对象的出生日期， 并显示信息。
JVM规范
编译完源程序以后，生成一个或多个字节码文件。我们使用JVT中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
虚拟机栈，即为平时提到的栈结构。我们将局部变量存储在栈结构中。
堆，我们将new出来的结构〈比如:数组、对象〉加载在对空间中。补充:对象的属性〈非static的)加载在堆空间中）
方法区:类的加载信息、常量池、静态域
一、理解“万事万物皆对象”
1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。
>scanner ,string等
>文件:File
>scanner ,string等>文件:File
2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
二、内存解析的说明
1.引用类型的变量，只可能存储两类值:null 或地址值（含变量的类型)
三、匿名对象的使用
1.理解:我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
2.特征:匿名对象只能调用一次。
3.使用:如下。
对数组操作进行封装
方法的重载
1.重载的概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
“两同一不同”:同一个类、相同方法名
参数列表不同:参数个数不同，参数类型不同
2.重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。 (参数个数或参数类型)。调用时， 根据方法参数列表的不同来区别。
3.判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系!
4．在通过对象调用方法时，如何确定某一个指定的方法:方法名—>参数列表
5.重载示例：
//返回两个整数的和
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;}
练习
2.编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别
执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的main ()方法中分别用参数区别调用三个方法。
3.定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值，并分别调用三个方法。
可变形参的方法
JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
//JDK 5.0以前： 采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0： 采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);
2.具体使用:
2.1 可变个数形参的格式:数据类型…变量名
2.2当调用可变个数形参的方法时，传入的参数个数可以是:0个，1个,2个，。。。
2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存
2.5 可变个数形参在方法的形参中，必须声明在末尾
2.6可变个数形参在方法的形参中,最多只能声明一个可变形参。
方法参数的值传递机制
方法，必须由其所在类或对象调用才有意义。若方法含有参数：
形参：方法声明时的参数
实参： 方法调用时实际传给形参的参数值
Java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种： 值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
方法的形参的传递机制:值传递
1.形参:方法定义时，声明的小括号内的参数
实参:方法调用时，实际传递给形参的数据
2.值传递机制:
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
练习6： 将对象作为参数传递给方法
（ 1） 定义一个Circle类， 包含一个double型的radius属性代表圆的半径， 一个findArea()方法返回圆的面积。
（ 2） 定义一个类PassObject， 在类中定义一个方法printAreas()， 该方法的定义
如下： public void printAreas(Circle c, int time)在printAreas方法中打印输出1到time之间的每个整数半径值， 以及对应的面积。例如， times为5， 则输出半径1， 2， 3， 4， 5， 以及对应的圆面积。
（ 3） 在main方法中调用printAreas()方法， 调用完毕后输出当前半径值。 程序运行结果如图所示。
下面展示一些 CircleTest。
package ToObject;
/**
* @author dell
* @version 11.0
* @ClassnameCircleTest
* @Description Do
* @date 2021/7/7 20:50
* @Project Java2018
**/
/*
将对象作为参数传递给方法
（1） 定义一个Circle类， 包含一个double型的radius属性代表圆的半径， 一个findArea()方法返回圆的面积。
（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 CircleTest {
public static void main(String[] args) {
System.out.println("Radius" + "\t\t" + "Area");
PassObject test = new PassObject();
Circle1 c = new Circle1();
test.printAreas(c,5);
}
}
class Circle1{
//圆的半径属性
double radius;
public double findArea(){
double area = Math.PI * radius * radius;
return area;
}
}
class PassObject{
public void printAreas(Circle1 c, int time){
for (int i = 1;i < time + 1;i++){
c.radius = i;
double area = c.findArea();
System.out.println(c.radius + "\t\t" + area);
}
}
}
递归方法
递归方法：一个方法体内调用它自身。
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
下面展示一些 DiGui。
package ToObject;
/**
* @author dell
* @version 11.0
* @ClassnameDiGui
* @Description Do
* @date 2021/7/7 21:14
* @Project Java2018
**/
public class DiGui {
public static void main(String[] args) {
//例1：计算1-100之间的所有自然数的和
//方式一
int sum = 0;
for (int i = 0;i <= 100;i++){
sum += i;
}
System.out.println("总和为：" + sum);
DiGui sum1 = new DiGui();
//int s = sum1.getSum(100);
System.out.println("总和为：" + sum1.getSum(100));
int s1 = sum1.getSum2(99);
System.out.println("乘积为：" + s1);
System.out.println(sum1.f(15));
System.out.println(sum1.f1(10));
}
//方式二
public int getSum(int n){
if (n == 1){
return 1;
}else{
return n + getSum(n - 1);
}
}
//计算1 至 n的所有值乘积
public int getSum2(int n){
if (n == 1){
return 1;
}else{
return n * getSum2(n - 1);
}
}
//已知有一个数列： f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0的整数，求f(10)的值。
public int f(int n){
if (n == 1 ){
return 1;
}else if (n == 2){
return 4;
}else{
return 2 * f(n - 1) + f(n - 2);
}
}
//输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值1 1 2 3 5 8 13 21 34 55
//规律：一个数等于前两个数之和
//要求： 计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来
public int f1(int n){
if (n == 1 || n == 2){
return 1;
}else{
return f1(n - 1) + f1(n - 2);
}
}
}
889
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
