零基础学Java（变量，递归，面向对象）

变量

变量的三要素：变量类型，变量名，作用范围(声明周期)

局部变量

声明在方法中或者是代码块中的变量是局部变量。

• 只在当前声明的方法中或代码块中有效
• 变量要在声明和初始化后才能被使用

代码示例

public class Test01 {
	public static void main(String[] args) {
		// 声明了一个代码块
		{
			//声明一个变量
			int num = 10;
			System.out.println(num);
		}
        //声明了一个局部变量
		int i = 20
		System.out.println(i);
	}

成员变量

声明位置：类中，方法外

• 在整个类中有效
• 成员变量都存在默认值：
  • 整形->0
  • 浮点型->0.0
  • 逻辑型->false
  • 字符型->空格（’\u0000’）
  • 引用类型->null

代码示例

public class Test02 {
	
	static int num;
	static byte b;
	static short s;
	static long l;
	static float f;
	static double d;
	static char ch;
	static boolean flag;
	static String str;
	
	public static void main(String[] args) {
		System.out.println(num);
		//int result ;
		//System.out.println(result);
		
		System.out.println(b);
		System.out.println(s);
		System.out.println(l);
		System.out.println(f);
		System.out.println(d);
		System.out.println(flag);
		System.out.println(str);
		System.out.println("+++"+ch+"+++");
	}
}	

递归

一种编程技巧，程序自己调用自己。

递归头 终止环节

递归体

优势： 能够更快的写出代码 复杂度特别低。

劣势： 特别消耗内存。

适用场景： 数据结构和算法

注意：

• 凡是可以使用递归程序的都可以使用循环，但是能够使用循环的不一定能够使用递归。
• 能够做到栈帧复用的递归程序称之为尾递归。

代码示例

/*  计算阶乘：
 *  	1! = 1
 *      2! = 1*2		2! = 1!*2
 *      3! = 1*2*3		3! = 2!*3
 *      .....
 *    	n! = (n-1)!*n	
 *    
 *    
 *    	if(){
 *    		return 1;
 *    	}else{
 *    		return fun(n-1)*n
 *    	}
 *
 */
public class Test03 {
	public static void main(String[] args) {
		System.out.println("通过循环计算一个数的阶乘");
		//声明变量存放阶乘的结果
		int result = 1;
		for(int i =1;i<=5;i++) {
			result = result*i;
		}
		System.out.println(result);	
		result = fun(30);		
		System.out.println(result);
	}
	
	//定义一个方法计算一个数的阶乘
	public static int fun(int num) {
		if(num==1) {
			return 1;
		}else {
			return fun(num-1)*num;
		}
	}	
}

尾递归

尾递归内存图

尾递归代码示例

package com.mage.var;

/**
 *  斐波那契数列：
 *  	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);
	}		
}

面向对象

语言在发展过程中，面向过程语言已经无法满足开发需求，逐渐发明出面向对象语言

人开车

​ 面向过程：

​ 1.考驾照

​ 2.买车

​ 3.打开车门

​ 4.踩离合，打火

​ …

​ 将一个问题，分成N多个小步骤，按步骤 按照顺序依次完成 整个功能就完成

​ 面向对象：

​ 人，车

​ 对象： 对象可以帮助你完成一些功能或者是愿望

​ 完成该功能中遇到的所有问题都和你无关 -> 更加轻松

面向对象和面向过程不是相对的，而是相辅相成。

面向对象和面向过程对比

面对对象： 宏观上把控整个事务的完成度以及事务走向。是对象帮我们处理具体的问题，而对象是如何做的，和调用者无关，调用者只需要负责结果即可。

调用的复杂度降低。底层具体的实现思路还是过程式的。

面向过程： 微观上更精细化的处理具体问题 。

类和对象的关系

类：

分门别类。抽象的概念 。祖先为了能够让后来的人更好的去认识这个世界，将各个具象的内容抽离出来一个一个的类。

对象：

将类中所有抽象的内容进行了具象化 。 现实生活中真实存在的。

类和对象：

类是对于对象的抽象，抽象就是抽取像的部分，对象就是对于类的具象化的体现

类中包含的内容：

​ 成员变量：从属于当前类的

​ 方法：对象完成 功能

编写类：
Person类： 将张三、李四。。。的相同的部分抽离出来：
外在的表现形式: 姓名、年龄。。。。 -> 成员变量
内在的功能： 能够做什么 -> 方法

问题：是先有类还是先有对象？

• 如果是编写过程： 先有类 再有对象
• 如果是构建过程： 先有对象，将对象的共性抽离出来，外在、内在->类

什么时候类会被加载

• 调用当前类中的静态方法。
• 创建当前类的实例对象的时候 。

面向对象第一个程序

package com.mage.var;
/**
 *创建一个Student类 
 */
public class Student {
	String name;//姓名
	int age;  //年龄
	int id;  //学号
	//学习方法
	public void study() {
		System.out.println("学习");
	}
	public void eat() {
		System.out.println("吃饭");
	}
	public void sleep() {
		System.out.println("睡觉");
	}
}

内存分析

static关键字

static的用法

• static叫做静态的 共享的 所属于类的 类被加载的时候会优先加载静态内容。

• static修饰的内容只有一份，被所有的对象以及类共享，对于static修饰的内容改变，也被所有对象可见。

• static修饰的内容两种调用方式：

• 通过类名直接点 类名. （建议）

• 通过对象调用 对象.

如何在一个静态内容中调用非静态内容

• 在非静态内容中加static。
• 创建非静态内容的所属对象 通过对象调用 。

在非静态内容中调用静态方法：

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);
    }
}