JAVA笔记(二)---方法、对象

方法Method

方法的本质：

方法就是一段代码片段，该代码片段可以完成某个特定功能，并且可以被重复使用。

在C语言中，方法被称为函数(Function)

方法定义在类体当中。方法体中不能再定义方法。

方法怎么定义，语法结构：

[修饰符列表] 返回值类型 方法名(形式参数列表)
{
方法体；
}

修饰符列表：
修饰符列表是可选项，不是必须的。
当方法的修饰符列表中有static关键字的话，调用这个方法：类名.方法名(实际参数列表)
当方法的修饰符列表中没有static关键字的话，调用这个方法：引用.方法名(实际参数列表)

形参属于局部变量

建议，一个java文件中，只定义一个class

public class method
{
	public static void main(String[] args)
	{
		method.sum(20, 14);//在同一个类中，method.可以省略。在不同类中，不可以省略
	}

	public static void sum(int a, int b)
	{
		int c = a + b;
		System.out.println(a + "+" + b + "=" + c);
	}
}

方法的内存相关：

方法只定义而没有调用，是不会执行的，并且也不会给该方法分配内存空间。
只有在调用这个方法的时候，才会动态的给这个方法分配所属的内存空间。

在JVM内存划分中，有三块主要的内存空间：
方法区
栈区
堆区

方法代码片段存储在哪里？方法执行的时候，执行过程的内存在哪里分配？
方法代码片段属于.class字节码文件的一部分，字节码文件在类加载的时候，将其放在了方法区。

方法区的代码段虽然只有一份，但是可以被重复调用。
每一次调用这个方法的时候，需要给该方法分配独立的活动场所。在栈内存中分配。

方法调用瞬间，会给该方法分配内存空间，并且在栈中发生压栈操作
方法执行结束之后，会将该方法分配的内存空间全部释放，并且在栈中发生出栈操作。

方法重载(overload)：

方法名相同，方法参数不同
功能相似的方法，可以使用方法重载。

方法重载需要满足哪些条件？

• 在同一个类里面
• 方法名相同
• 参数列表不同（数量不同 或者 参数顺序不同 或者 参数类型不同）

方法重载与参数有关，与返回类型无关，与修饰符无关

public class k//类体
{
	public static void main(String[] args){//方法体
		
	}

	public static void method1(int a){

	}

	public static int method1(int a){
			
	}
}

错误: 已在类 k中定义了方法 method1(int)
	public static int method1(int a){
	                  ^
1 个错误

递归

递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误。

求从1到N的和：

方法一：

public class method
{
	public static void main(String[] args)
	{
		System.out.println(sum(100));
	}

	public static int sum(int n)
	{
		int sum = 0;
		for (int i = 1; i<=n; i++) {
			sum += i;
		}
		return sum;
	}
}

方法二：递归

public class method
{
	public static void main(String[] args)
	{
		System.out.println(sum(100));
	}

	public static int sum(int n)
	{
		if (n == 1) {
			return 1;
		}
		return n + sum(n-1);
	}
}

递归尽量从后往前写，最小处作为结束条件。
比如1到N的和，从n+sum(n-1)，n==1的时候是结束条件。

---

面向对象

面向过程和面向对象的区别：
面向过程：主要关注点：实现的具体过程，因果关系（集成显卡的开发思路）
* 优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。
* 缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑，另外面向过程的方式导致软件元素之间的”耦合度“非常高，扩展性低。

面向对象：主要关注点：对象（独立体）能完成哪些功能（独立显卡的开发思路）
* 优点：耦合度低，扩张性强。适合复杂问题的解决
* 缺点：前期投入较高，需要进行独立体的抽取，大量的系统分析与设计。

你有对象吗？

面向对象的三大特征：
封装
继承
多态

采用面向对象的方式开发一个软件，生命周期中：（OO面向对象）
面向对象的分析：OOA（Object-Oriented Analysis）
面向对象的设计：OOD（Object-Oriented Design）
面向对象的编程：OOP（Object Oriented Programming）

---

类和对象

什么是类？
类在现实世界中是不存在的，类是一个模板，是一个概念。是人类大脑思考抽象的结果
类代表了一类事物

什么是对象？
对象是现实世界存在的实际存在的个体。
对象又被称为实例instance

类是抽象的，对象是具体的。

类 通过 实例化 new出对象
对象 抽象出 类

类由属性和方法组成
类{
属性;描述对象的状态信息
方法;描述对象的动作信息
}

基本数据类型
引用数据类型

Java语言中，所有的class都属于引用数据类型

通过一个类可以实例化N个对象（想创建多少创建多少）
实例化对象的语法：new 类名()
new运算符的作用是创建对象，在JVM堆内存当中开辟新的内存空间

方法区内存：在类加载的时候，class字节码代码片段被加载到该内存空间当中
栈内存 （局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈
堆内存：new的对象在堆内存中存储。

int i = 10;
int 是一个基本数据类型
i是一个变量名
10是一个int类型的字面值

Student s = new Student();
Student 是一个引用数据类型
s是一个变量名
new Student()是一个学生对象

什么是对象？
new运算符在堆内存中开辟的空间成为对象
new Student()

什么是引用？
引用是一个局部变量，这个变量保存了另一个java对象的内存地址（其实就是C中的指针变量）

老师建议：不要将s叫做对象，这个建议非常好。
在OC中，Person *p = [[Person alloc] init];
常常称Person为类对象，p为对象。其实，p是一个指针变量
[[Person alloc] init]才是真正在堆空间创建的对象。
因此，
Student s = new Student();
s称为引用，new Student()称为对象

在Java中，程序员不能够直接操作堆内存。
因此，必须经过引用才能访问堆内存当中的对象。

访问实例变量的语法格式：
读取数据：引用.变量名
修改数据：引用.变量名 = 值

p112集非常重要

//Student是类，属于引用数据类型，这个类型名就是：Student
public class Student
{

	//类体 = 属性 + 方法
	//属性【存储数据采用变量的形式】
	//由于变量定义在类体当中、方法体之外，因此，这种变量被称为 成员变量
	//所有学生都有学号信息，但每一个学生的学号都是不同的
	//所以，要访问这个学号，必须先创建对象，通过对象去访问学号信息
	//学号信息不能直接通过 类 去访问，所以，这种成员变量又被叫做：实例变量
	//对象又被称为实例，实例变量又被称为对象变量
	//不创建对象，这个no变量的内存空间是不存在的，只有创建了对象，这个no变量内存空间才会创建。
	int no;

	int age;
	boolean sex;
	String addr;

	public static void main(String[] args)
	{

	}

	public void run()
	{	
		age = 10;
		System.out.println("跑"+age);
	}

}

public class k//类体
{
	public static void main(String[] args){//方法体
		Student s = new Student();

		s.info();

		s.no = 10;
		s.name = "jack";
		s.age = 20;
		s.sex = true;
		s.addr = "北京";

		s.info();

		Student stu = new Student();
	}

}

局部变量 在栈内存中存储
成员变量中的实例变量 在堆内存的对象内部存储

上例中，Student s = new Student();是定义在方法体之内，因此，
s是局部变量。
s又被称为引用。
new Student()是对象
int age是实例变量。

实例变量是一个对象一份，100个对象有100份

JAVA
局部变量：方法体之内定义的变量
成员变量：类体之内、方法体之外定义的变量

OC
成员变量、属性变量、局部变量

@interface ViewController : UIViewController
{
        //成员变量
        NSArray *array1;
}
//属性变量
@property (nonatomic,strong) NSArray *array2;
@end

@implement
    - (void)viewDidLoad
    {
        [super viewDidLoad];
        array1 = [[NSArray alloc] initWithObjects:@"abcde", nil];
        array2 = [[NSArray alloc] initWithObjects:@"123abc", nil];
        {
    //        局部变量
            NSArray *array1 = [[NSArray alloc] initWithObjects:@"12345", nil];
        }
        NSLog(@"\narray1 : %@\n array2 : %@",array1,array2);
    }
@end

小总结

1. JVM(java虚拟机)主要包括三块内存空间：方法区内存、栈内存、堆内存
2. 方法区内存和堆内存各有一个，一个线程一个栈内存
3. 方法调用的时候，该方法所需要的存储空间在栈内存中分配，称为压栈。方法执行完毕之后，该方法所需的内存空间释放，称为出栈。
4. 栈中主要存储的是方法体当中的局部变量
5. 方法的代码片段以及整个类的代码片段都被存储到方法区内存中，在类加载的时候，这些代码片段会载入
6. 在程序执行过程中，使用new运算符创建的java对象，存储在堆内存当中。对象内部有实例变量，因此，实例变量存储在堆内存中。
7. 变量的分类：
   局部变量：方法体内声明
   成员变量：类体之内、方法体之外声明
   而成员变量又分为：
   实例变量：前面修饰符没有static
   静态变量：前面修饰符中有static
8. 静态变量存储在方法区内存中
9. 三块内存中：变化最频繁的是栈内存；最先有数据的是方法区内存；垃圾回收器主要针对的是堆内存。
10. 垃圾回收器（自动垃圾回收机制、GC机制）什么时候会考虑将某个java对象的内存回收呢？
    当堆内存中的java对象成为垃圾数据的时候，会被垃圾回收器回收
    那什么时候堆内存中的java对象会变成垃圾呢？
    没有更多的引用指向它的时候，这个对象无法被访问，因为访问对象只能通过引用的方式访问，然后就变为了垃圾数据。