入坑Java（六）详谈类与对象

类的构造方法

简单来说就是跟类名字一样的无参数方法，跟类名字一样的无参数方法就是类的构造方法，比如：

public class TryFirst {
 TryFirst() {}
}

我们之前说方法名首字母小写，这个就不用，因为这个是构造方法，要的就是跟类名一样，大小写也是啦。
如果变成：

public class TryFirst {
 TryFirst(int a) {}
}

方法有参数的话，那就不是咯！切记！！
构造方法有什么用嘞，它其实是在类被实例化（TryFirst tryFirst = new TryFirst()）的时候会被调用的方法，不需要再tryFirst.TryFirst()，就可以被调用了。这个构造方法就算你不写，系统也会自动给它弄一个构造方法的，只是方法里面是空的而已啦。自己写的话，就可以在方法里写自己想写的代码了。

类里面的成员变量和局部变量

1）介绍变量，通过例子来讲吧，如下：

public class TryFirst {
//直接写在类{}下的就是成员变量啦，如下
	int a = 11;
	
//写在方法里面的就是局部变量啦，如下
 void oneWay(int b) {
     int a = 22;
	 int c = 33 ;
}

其中的a就是成员变量啦，而b和c则是局部变量，通过例子也可以看出来，只要不是直接写在类{}下的，都是局部变量，其中b是写在{（）}里的，c是写在{{}}里的，而方法里的a（int a = 22;）是写在{{}}里的，都不是直接写在类的{}里的啦。
区别：成员变量在类的{}里都可以调用到，而局部变量只能在局部被调用，并不是在整个类{}里都可以调用。比如我想在oneWay方法之外调用c这个变量，这就做不到，但如果我想在方法oneWay里调用a变量，只需要在oneWay里写：this.a 就可以调用了。如果不是在方法内调用，直接写a就可以调用。
还有注意区分类的a（int a = 11;）和方法的a（int a = 22;）哦！他们两个可不一样，一个是成员变量一个是局部变量，也就是为了在方法里区别两个a，所以当在方法里用成员变量的时候，要写成this.a 当要用局部变量的时候，也就是方法里面的a的时候，直接写a就可以了。可能有人会问，那怎么在方法外区分它们呢？不存在这种可能呢，因为局部变量只能在相应的方法里被调用啊，在方法之外就用不了了，所以，如果是在方法外的话，就只有成员变量了，不需要区分，直接写a姐可以，比如：

public class TryFirst {
	int a = 11;
 void oneWay(int b) {
	 int a = 22;
	 int c = 33;
	 //在方法里调用局部变量的a（ int a = 22;）
	 System.out.println(a);
	
	 //在方法里调用成员变量的a（ int a = 11;）
	 System.out.println(this.a);
}
 //在方法之外只能调用成员变量,下面的a就是上面的成员变量（int a = 11;）
 int d = a;

需要注意一下this的用法：
a.this在static修饰的方法了是不可以用的

b.除了可以区分使用同名成员变量和局部变量外，还可以在方法中调用其它方法

package com.see;

public class TryUseThis {
	String str = "成员变量";

	public void one() {
		this.two();
	}

	public void two() {
		String str = "局部变量";
		System.out.println("方法用this调用别的方法" + "、 " + str + "、 " + this.str);
	}

	public static void main(String[] args) {
		TryUseThis tryUseThis = new TryUseThis();
		tryUseThis.one();
	}
}

c.可以通过this来调用类的有参数的构造方法，（一般类只有一个是无参数的构造方法）：

//在无参构造方法里调用有参构造方法时，需要将"this(参数)"写在第一行，不然会报错的
public class TryUseThis {
	TryUseThis(int a) {
		System.out.println("有参构造方法"+a);
	}
	TryUseThis() {
		this(0);//这个要写在第一行！（注意大小写）
		System.out.println("无参构造方法"+1);
	}
}

2）调用变量

成员变量又叫类变量，它在类被加载的时候，就被实例话了。什么叫实例化呢，就是被分配内存了。如果一个变量没有被分配内存，它就不是实际存在的。只有程序结束运行的时候，才会释放内存
而局部变量，也就是方法里的变量，它们一开始的时候是不被分配内存的，只有方法被调用的时候，局部变量才会分配内存，即被实例化。当该方法调用完毕时，局部变量分配的内存就会被释放掉。

有时候人家会问，为什么编辑器都已经编译好了，当方法背调用的时候还能再分配内存呢？难道是重新编译吗？
其实不是的啦，方法中的变量，也就是局部变量，其实在被分配内存的全过程都是在一个栈内完成的，所用空间也是栈空间，跟成员变量的空间不同，它们是不一样的，所以被释放的时间也不一样。

可能有些人还会问，曾元变量一开始就被赋予了内存空间，但如果成员变量在一开始并没有赋值的话，赋予空间的值又是多少呢？
细心的人会发现，就算一开始成员变量没有被赋值，比如写成这样int a;也不会报错，也并没有赋值，当这种情况，系统会赋值其的默认值，int 的默认值为0，String的默认值为null ，而boolean 的默认值为false。这些都是成员变量的赋值哦！要是写在main方法里面，比如也写成int a；这个时候就不会被赋值了，毕竟main方法也是方法嘛，这不能算作是成员变量。

3）被static修饰的特殊成员变量——类成员变量
被static修饰的成员变量也是成员变量，但它在各个对象里被调用是共同的，也就是各个对象共享这个类成员变量。举个例子说明吧：

public class TryFirst {
 	int a = 1;
 	static int b = 3;
 	public static void main(String[] args) {
 		//实例化两个对象
 		TryFirst tryFirst1 = new TryFirst();
 		TryFirst tryFirst2 = new TryFirst();
 		tryFirst1.a = 2;
 		System.out.println(tryFirst1.a);
 		System.out.println(tryFirst2.a);
 		tryFirst1.b = 4;
 		System.out.println(tryFirst1.b);
 		System.out.println(tryFirst2.b);
	}
	}

你会发现输出结果是

2
1
4
4

这就是有static修饰和没static修饰的区别。被static修饰的成员变量，在对象中是共享的，当tryFirst1改变它的值时，tryFirst2调用的就是被改变的值。
而没有static修饰的陈冠变量，变量是单独的，不受对象的影响，当tryFirst1改变它的值时，它的实际值并未被改变，所以当tryFirst2调用它时，它还是原先的值。

方法的重载

方法名可以一样吗？答案是：可以。但是是有条件的可以，条件是：必须存在不同属性的参数或者不同数量的参数。怎么个意思嘞，举个例子吧：

public class TryFirst {

 	void oneWay() {}
 	void oneWay(int a) {}
 	void oneWay(short a) {}
 	void oneWay(int a,int b) {}
 	}

上面的四个方法都叫oneWay，你会发现编译不会报错，这就是方法的重载，除了名字外，它们分别都有各自的不同，第一个的参数为0个，第二个的参数为1个，而第三个的参数类型与第二个的不同，第四个的参数数量是2个，跟前几个都不一样。

方法的返回值

我们都知道方法的写法是：void wayName(){}
那你知道void是什么意思吗？其实void表示的就是“返回空”的意思，其实方法是可以返回一个值的，只是之前我们都没有到而已，所以就没有。那么可以返回什么类型的值呢？又需要怎样才能返回呢?
能返回所有类型的值 比如8大基本参数类型，byte，int，short，long，float，double，boolean,char 以及String类型也能返回。还有所以类型的父类object也能返回。
返回方法：将void 改成你想返回的参数类型，然后在方法后面return 一个参数即可，具体如下例：

public class TryFirst {
 	public static void main(String[] args) {
 		//实例化两个对象
 		TryFirst tryFirst1 = new TryFirst();
 		int a = tryFirst1.oneWay();
 		System.out.println(tryFirst1.oneWay());
 		System.out.println(a);
	}
	int oneWay() {
		int c = 5;
		return c;
	}

我的方法名叫oneWay 而我返回的参数类型是int型，返回的是c（return c），当我们调用这个方法的时候，这个方法无形地就变成了一个值，我可以直接这么写System.out.println(tryFirst1.oneWay());
也可以通过赋值给自己定义的参数然后再int a = tryFirst1.oneWay(); System.out.println(a);
一般不建议再一次赋值，因为这样还要分配一个内存空间给它，没必要，所以能直接写就直接写，不要赋值。

被static修饰的方法

被static修饰的方法在一开始就被分配了入口地址，而没有static修饰的方法在一开始的时候并没有被分配这个入口地址，没有入口地址，就不能直接调用该方法，而有入口地址的就可以直接通过入口地址调用方法。举例说明吧：

public class TryFirst {
 	public static void main(String[] args) {
 		oneWay();
 		TryFirst tryFirst = new TryFirst();
 		tryFirst.twoWay();
	}
 	
	static void oneWay() {
		System.out.println("被static修饰的方法，一开始就有方法的入口地址");
	}
	void twoWay() {
		System.out.println("没被static修饰的方法，一开始没方法的入口地址");
	}
	}

通过例子我们可以发现，oneWay不需要先实例化对象就可以使用，而twoWay则需要先实例化对象后才能使用，这就是被static修饰与否的区别。

----------END