函数的传参方式

基本类型实际参数给形式参数传递值

引用类型由于本身存的是地址值，传参数时相当于传递地址

面向对象（OOP）

定义类、创建对象、封装、继承、多态、接口

优点

1.代码在多个类中，方便多人开发

2.隐藏实现细节（封装）

3.将大型的任务分割成多个互不影响的小的任务

4.实现了并行开发，极大提高了开发效率

类

实质

1.代码，数据的容器

2.相当于自定义的数据类型

3.本质上是一种自定义的数据类型（一种数据结构：可包含其他数据类型，包括基本数据类型、引用数据类型、其他类）

类的内部成员

1.静态属性 成员变量

2.动态行为 （成员）方法

3.构造方法（构造器）

没有返回值类型且方法名与类名一致的方法。

系统在用户没有定义构造方法时会自动提供一个无参无操作的构造方法。一旦用户自定义了构造方法，系统不再提供。

例：

public class ClassTest {
	ClassTest(){
		System.out.println("无参构造方法");
	}
	ClassTest(String tip){
		System.out.println(tip);
	}
}
ClassTest classTest = new ClassTest();
ClassTest classTest1 = new ClassTest("有参构造方法");
/*
 * 输出信息：
 * 无参构造方法
 * 有参构造方法
 */

4.代码块

5.注解（一种特殊的接口）

@Override // 表示它下面的方法是一种重写
public @interface Override
/*API文档解释
表示方法声明旨在覆盖超类型中的方法声明。 如果使用此注释类型注释方法，则除非至少满足以下条件之一，否则需要编译器生成错误消息： 
该方法将覆盖或实现在超类型中声明的方法。 
该方法具有与Object中声明的任何公共方法的覆盖相同的签名 。 
*/
@Override
public  String toString() {
	return null ;
}

6.内部类（内部接口）

类里面定义的类

例：

public class IntraClassTest {
	// 定义无参构造方法
	IntraClassTest(){
		System.out.println("创建普通类对象");
	}
	
	// 定义一个内部类
	public class IntraClass{
		// 定义内部类有参构造方法
		IntraClass(String string){
			System.out.println(string);
		}
	}
	
	// 定义初始化内部类的方法，创建一个内部类对象
	public void initIntraClass() {
		IntraClass intraClass = new IntraClass("创建内部类对象");
	}
}

IntraClassTest intraClassTest = new IntraClassTest();
intraClassTest.initIntraClass();
/*
 * 输出结果为：
 * 创建普通类对象
 * 创建内部类对象
 */

创建对象

实质：类的实例化（通过new操作符执行构造方法创建对象并使得变量指向对象）。

IntraClassTest intraClassTest = new IntraClassTest();
/*
 * IntraClassTest	自定义数据类型（类）
 * intraClassTest	自定义数据类型（类）的变量（保存对象地址的变量）	存在在栈内存区
 * new IntraClassTest();	这部分才是对象		存在在堆内存区
 */

总结

函数传参特列

String

public static void main(String[] args) {
		String string = "Hello World";
		System.out.println("测试前："+string);
		testString(string);
		System.out.println("测试后："+string);

		StringBuffer stringBuffer = new StringBuffer("Hello World1");
		System.out.println("测试前："+stringBuffer);
		testStringBuffer(stringBuffer);
		System.out.println("测试后："+stringBuffer);
	}

	private static void testString(String string) {
		string = "test String";
		System.out.println("方法内的："+string);
	}
	
	private static void testStringBuffer(StringBuffer string) {
        // String的append()方法可在字符串后追加一个字符串
		string.append(" test StringBuffer");
		System.out.println("方法内的："+string);
	}
/*
 * 输出结果为 
 * 测试前：Hello World
 * 方法内的：test String
 * 测试后：Hello World
 * 测试前：Hello World1
 * 方法内的：Hello World1 test StringBuffer
 * 测试后：Hello World1 test StringBuffer
*/

注意：

1.基本类型的变量存在在栈内存区

2.引用型的变量存在在栈内存区内，其所指向的对象存在在堆内存区

java在方法传递参数时，是将变量复制一份，然后传入方法体去执行。

基本类型的传递：

/*
1.虚拟机分配给num一个内存地址，并且存了一个值0.
2.虚拟机复制了一个num，我们叫他num’，num’和num的内存地址不同，但存的值都是0。
3.虚拟机讲num’传入方法，方法将num’的值改为1.
4.方法结束，方法外打印num的值，由于num内存中的值没有改变，还是0，所以打印是0.
*/

引用型传递：

/*
1.虚拟机在堆中开辟了一个Product的内存空间，内存中包含proName和num。
2.虚拟机在栈中分配给p一个内存地址，这个地址中存的是1中的Product的内存地址。
3.虚拟机复制了一个p，我们叫他p’,p和p’的内存地址不同，但它们存的值是相同的，都是1中Product的内存地址。
4.将p’传入方法，方法改变了1中的proName和num。
5.方法结束，方法外打印p中变量的值，由于p和p’中存的都是1中Product的地址，但是1中Product里的值发生了改变，所以，方法外打印p的值，是方法执行以后的。我们看到的效果是封装类型的值是改变的。
*/

String的传递：

/*
1.虚拟机在堆中开辟一块内存，并存值”ab”。
2.虚拟机在栈中分配给str一个内存，内存中存的是1中的地址。
3.虚拟机复制一份str，我们叫str’，str和str’内存不同，但存的值都是1的地址。
4.将str’传入方法体
5.方法体在堆中开辟一块内存，并存值”cd”
6.方法体将str’的值改变，存入5的内存地址
7.方法结束，方法外打印str，由于str存的是1的地址，所有打印结果是”ab”
*/

类与对象的区别：

类表示一类事物，对象是一类事物中的具体一个，指向哪个具体的事物的过程就是类的实例化

对象是具有类类型的变量。 类是对象的抽象，而对象是类的具体实例。 类是抽象的，不占用内存，而对象是具体的，占用存储空间。 类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

当需要表示一类事物时，可自定义一个类（一个数据结构）记录和存储事物

问题

这里书写今日所遇到问题及解决方法 不要忽略小问题，小问题也要记下来。( 勿以善小而不为 )

String对象为引用型但是在传参时却是传递它的内容？？？

传参的实质是复制一份实参变量传递到方法中，由于基本数据类型存在在栈内存，传递进去是值。

而引用类型对象存在在堆内存，而它的引用存在在栈内存，复制变量相当于复制地址，相当于传递地址

String比较特殊。传递时同样是复制了地址，但是在方法体中却是重新开辟堆内存其引用为复制的那个，

出了方法体后仍指向之前指向的堆内存故而方法中改变而值未改变

吐槽

这里是吐槽部分，内容不限。