本节内容为昨天未讲完的内容
本节知识大纲：
递归
递归：
一种编程技巧，程序中自己调用自己
结构：
递归头 终止环节（出口）
递归体
优势： 能够更快的写出代码 复杂度特别低
劣势： 特别消耗内存
凡是可以使用递归程序的都可以使用循环，但是能够使用循环的不一定能够使用递归
使用场景：数据结构和算法
能够做到栈帧复用的递归程序称之为尾递归
java.lang.StackOverflowError SOFE 栈内存溢出 一定要小心
//定义一个方法计算一个数的阶乘
public static int fun(int num) {
if(num==1) {
return 1;
}else {
return fun(num-1)*num;
}
}
尾递归
/**
* 斐波那契数列：
* 1 1 2 3 5 8 13 21 。。。
*
* 第一项 ： 1
* 第二项 ： 1
* 第三项 ： 第一项+第二项
* 。。。。。。
* f(n) = f(n-1)+f(n-2)
*
*
* 4 1 1
* 计算的第n项 前一项 前两项
*
* @author wawjy
*
*/
public class Test04 {
public static void main(String[] args) {
//定义计算的项数
int num = 50;
System.out.println("使用循环完成斐波那契数列");
//记录时间 获取到的是当前时间的毫秒数
long start = System.currentTimeMillis();
long num1 = 1;
long num2 = 1;
long result = 0;
for(int i = 3;i<=num;i++) {
result = num1+num2;
num1 = num2;
num2 = result;
}
long end = System.currentTimeMillis();
System.out.println("循环之后第30项的值是："+result+"，总耗时："+(end-start));
/*
* start = System.currentTimeMillis(); result = method(num); end =
* System.currentTimeMillis();
*
* System.out.println("递归之后第30项的值是："+result+"，总耗时："+(end-start));
*/
start = System.currentTimeMillis();
result = method(num,1,1);
end = System.currentTimeMillis();
System.out.println("递归之后第50项的值是："+result+"，总耗时："+(end-start));
}
public static long method(int num) {
if(num==1||num==2) {
return 1;
}
return method(num-1)+method(num-2);
}
public static long method(long num,long ret1,long ret2) {
if(num==1) {
return ret1;
}
return method(num-1,ret2,ret1+ret2);
}
}
尾递归内存图
打印菱形
常规方法：
public class test05 {
public static void main(String[] args) {
for(int i = 1;i<=4;i++) {//控制行数
for(int j = 1;j<=2*i-1;j++) {//控制星星个数的时候和行有关
System.out.print("*");
}
System.out.println();
for(int i = 1;i<=4;i++) {//控制行数
for(int k = 1;k<=4-i;k++) {//空格的个数
System.out.print(" ");
}
for(int j = 1;j<=2*i-1;j++) {//控制星星个数的时候和行有关
System.out.print("*");
}
System.out.println();
}
}
}
优化方法：
public class test05 {
public static void main(String[] args) {
print07();
}
public static void print07() {
char ch = 'I';
for(int x = -5;x<=5;x++) {
for(int y = -5;y<=5;y++) {
if((x>0?x:-x)+(y>0?y:-y)<=5) {
System.out.print((char)(ch+y));
}else {
System.out.print(" ");
}
}
System.out.println();
}
}
使用Eclipse
下载
安装：点击下一步傻瓜式安装即可
注意事项
1： 所有的项目都会统一放置在eclipse最开始需要选择的workspace中
2： 创建的所有的项目中的src中存放的是当前项目的源文件.java文件
3： Eclipse不需要手动编译，自动会将.java文件编译位对应的.class文件。该文件存储在当前工作空间\项目\bin
4： Eclipse在内部是配置了-classpath的
面向对象
什么是面向对象
面向对象和面向过程的关系
语言在发展过程中，
人开车
面向过程：
1：买辆车
2：考驾照
3：打开车门
4：踩离合，打火
5：挂挡、松离合、踩油门
。。。。
将一个问题，分成N多个小步骤，按步骤 按照顺序依次完成 整个功能就完成
面向对象：
对象： 对象可以帮助你完成一些功能或者是愿望
完成该功能中遇到的所有问题都和你无关 -> 更加轻松
驾驶员、人，车
面向对象和面向过程不是相对的，而是相辅相成。
面向对象和面向过程的对比：
面对对象：宏观上把控整个事务的完成度以及事务走向。
是对象帮我们处理具体的问题，而对象是如何做的，和调用者无关，调用者只需要负责结果即可。
调用的复杂度降低。底层具体的实现思路还是过程式的。
面向过程：微观上更精细化的处理具体问题
类和对象的关系
class类和对象有啥关系？java中如何创建对象?类中编写的内容有哪些?
成员变量：从属于当前类的
方法：对象完成 功能
编写类：
Person类： 将张三、李四。。。的相同的部分抽离出来：
外在的表现形式: 姓名、年龄。。。。 -> 成员变量
内在的功能： 能够做什么 -> 方法
类：
分门别类。抽象的概念 。祖先为了能够让后来的人更好的去认识这个世界，将各个具象的内容抽离出来一个
个的类。
对象：
将类中所有抽象的内容进行了具象化 。 现实生活中真实存在的。
类和对象：
类是对于对象的抽象，抽象就是抽取像的部分
对象就是对于类的具象化的体现。
问题：
先有类还是先有对象?
如果是编写过程： 先有类 再有对象
如果是构建过程： 先有对象，将对象的共性抽离出来，外在、内在->类
面向对象的第一个程序
程序代码
public class Person {
static String loc = "地球";
String name;// 姓名
int age;//年龄
boolean gender;//性别
//功能
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void play() {
System.out.println("打豆豆");
study();
}
public static void study() {
System.out.println("学习");
}
}
内存分析：
static
static的用法：
static叫做 静态的 共享的 所属于类的 类被加载的时候会优先加载静态内容
static修饰的内容只有一份，被所有的对象以及类共享，对于static修饰的内容改变，也被所有对象可见
static修饰的内容两种调用方式：
通过类名直接点 类名. （建议）
通过对象调用 对象.
如何在一个静态内容中调用非静态内容：
1：在非静态内容中加static
2:创建非静态内容的所属对象 通过对象调用
在非静态内容中调用静态方法：
1：可以直接调用，
原因是非静态内容隶属于对象，如果非静态内容能够被调用，对象一定存在，对象存在证明类一定能被加载。
什么时候类被加载而类被加载，静态内容一定被加载。
代码：
public class Test02 {
//声明一个变量
int num;//加载Test02类的时候，首先会加载当前类中的所有的static修饰的内容
public static void main(String[] args) {
//创建当前非静态变量所属的对象
Test02 t = new Test02();
System.out.println(t.num);
//直接方法person中的loc
Person p = new Person();
System.out.println(Person.loc);
System.out.println(p.loc);
}
}
什么时候类被加载
问题：
什么时候类会被加载?
1:调用当前类中的静态方法
2:创建当前类的实例对象的时候