java 之 面向对象

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1、面向对象特征：	1	封装（encapsulation)
					2	继承（inheritance)
					3	多态（polymorphism)

2、成员变量和局部变量的区别：
	1 成员变量：
		a 成员变量定义在类中，在整个类中都可以被访问
		b 成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象
	所在的堆内存中。
		c 成员变量有默认的初始值

	2 局部变量：
		a 局部变量定义在局部范围内，如函数，语句内等，只在所属的区域内有效
		b 局部变量存储在栈内存中，作用范围结束，变量空间就会释放
		c 局部变量没有默认初始化值。未初始化不能使用。（编译报错）

3、匿名对象
	匿名对象是对象的简化形式。
	匿名对象的使用情况
		1 当对对象方法进进行一次调用时
		2 匿名对象作为实际参数进行传递
		————————————————————————————————————————————————————
		class Car
		{
			public void run(){
				System.out.println("This is a Anonymous	class demo.");
			}
		}
		class CarDemo
		{
			public static void main(String[] args){
				new Car().run();//建立一个匿名对象，调用对象方法
				show(new Car());//新建一个匿名对象作为函数参数
			}
			public static void show(Car car){
				car.run();
			}
		}
		————————————————————————————————————————————————————
4、基本数据类型参数及引用数据类型参数传递
	1 基本数据类型参数传递（传值）：
		class Demo
		{
			public static void main(String[] args){
				int x = 3;
				show(x);
				System.out.println("x = "+x);
			}
			public static void show(int x){
				x = 4;
			}
		}

		输出结果：x = 3;

		过程分析：
			1 JVM调用main方法，main方法入栈
			2 将x变量设置为3
			3 main方法调用show，并将3作为基本数据类型传递给show方法的参数x，
		即参数x的值是3
			4 show方法执行x=4后，show方法的参数x值变为4
			5 show方法执行结束，show方法出栈。 show方法参数x也随之出栈
			6  main方法打印x的值。 此时x指的是main方法中的x变量的值（show方法中的参数x已经随show方法一块
		出栈了）。 所以，打印出来的x值为3而不是4。
			7 main方法执行结束，出栈。

	2 引用数据类型参数传递（传址）：
		class Demo
		{
			int x = 3;
			public static void main(String[] args){
				Demo d = new Demo();
				d.x = 9;
				show(d);
				System.out.println(d.x);
			}
			public static void show(Demo d){
				d.x = 4;
			}
		}
		输出结果： 4

		过程分析：
			1 jvm调用main方法，main方法入栈。
			2 在堆内存中创建一个类Demo的对象，在栈中建立变量d，并将d指向堆中
		新建的对象，然后将此对象的x设为9
			3  main方法调用show方法，d作为引用数据类型参数赋值给show方法参数d，也就是说，此时show方法的
		参数d和main方法中的变量d同时指向了堆内存中同一个实体对象
			4 show方法执行d.x=4后，堆内存中的实体对象的x属性值变为4
			5 show方法执行结束，show方法出栈，show方法参数d也随之出栈。 虽然show方法参数d出栈了，但是，
		由于main方法的变量d依然引用着堆内存中的实体对象，因此堆内存中的实体对象不会被垃圾回收器清除。
			6 main方法打印d.x的值。 此时，d指的是main方法中的引用变量x，d.x指的依然是堆内存中的实体对象中x
		的值。 所以，打印出来的值为4而不是9。
			7 main方法执行结束，出栈

	总结：在java中，方法参数的传递永远都是传值，而这个值，对于基本数据类型，值就是你赋给变量的那个值。
而对于引用数据类型，这个值是对象的引用（对象的地址），而不是这个对象本身。

5、封装：指隐藏对象的属性和实现细节，进对外提供公共的访问方式

		好处：
			1 将变化隔离
			2 便于使用
			3 提高了重用性
			4 提高了安全性

		封装的原则：
			1 将不需要对外提供的内容全部隐藏起来
			2 把属性隐藏，提供公共的方法对其访问。如getXxx,setXxx

		PS：
			1 私有是封装的一种体现
			2 private 关键字：是一个权限修饰符，用于修饰成员（变量和方法），被私有化的成员
		只在本类中有效
			3 常用场景之一：将成员变量私有化，对外提供对应的set、 get方法对其进行访问，提高对数据访问的安全
		性。

6、构造函数
	特点：
		1 函数名和类名相同
		2 不用定义返回值类型
		3 没有具体的返回值
	PS:在构造函数前面加上返回值类型就只是一般函数了
		定义类时，当不显式给出构造函数，则系统默认提供一个无参数的构造函数，当给出构造函数后，系统将不在提供
	隐士的构造函数。
	————————————————————————————————————————————————————————————
		class Student
		{
			private String name;
			Student(String name){
				this.name = name; //给出显式的构造函数
			}
		}
		class StudentDemo
		{
			public static void main(String[] args){
				Student s1 = new Student("hah");//成功
				Student s2 = new Student();//失败，隐士构造函数被重写，必须带参数
			}
		}
	————————————————————————————————————————————————————————————
	构造函数作用：给对象进行初始化

	1 一般函数和构造函数什么区别呢？
		
		构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
		一般函数：对象创建后，需要函数功能时才调用。

		构造函数：对象创建时，会调用并且只调用一次。
		一般函数：对象创建后，可以被调用多次。

	2 创建对象都必须要通过构造函数初始化。

		一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
		如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。
	
	3 多个构造函数是以重载的形式存在的。
	————————————————————————————————————————————————————————————
			class Person
			{
				private String name;
				private int age;
				Person(){};//无参数构造函数

				Person(String name,int age){//一创建就有名字和年龄
					this.name = name;
					this.age = age;
				}
				//一创建就有名字
				Person(String name){
					this.name = name;
				}

				public void speak(){
					System.out.println("name = "+name+"...age = "+age);
				}
			}
			class PersonDemo
			{
				public static void main(String[] args){
					Person p1 = new Person();
					Person p2 = new Person("Lily",12);
					Person p3 = new Person("Lucy");//多个构造函数通过重载方式实现不同的初始化
				}
			}
	————————————————————————————————————————————————————————————

7、 this 关键字
		this代表其所在函数所属对象的引用。 换言之，this代本类对象的引用。
	当成员变量和局部变量重名，可以用关键字this来区分，this就是所在函数所属对象的引用。
	简单说，哪个对象调用了this所在的函数，this就代表哪个对象。 一般方法调用默认加this。

		PS:通过 this在构造函数中调用其他构造函数的时候，只能定义在构造函数的第一行，因为初始化动作
	要先进行，否则会报错。

			class Person {
				private String name;
				private int age;
				Person(){};//无参数构造函数

				//一创建就有名字
				Person(String name){
					this.name = name;
				}
				Person(String name,int age){//一创建就有名字和年龄
					this.age = age;
					this(name);//错误。this调用构造器应该放在第一行
				}
				public void speak(){
					System.out.println("name = "+name+"...age = "+age);
				}
			}

			编译结果：Constructor call must be the first statement in a constructor

8、 static 关键字：用于修饰成员（成员变量和成员函数）
		1 被修饰后的成员有如下特点：
			1 随着类的加载而加载
			2 优先于对象存在
			3 被所有同类的对象共享
			4 可以直接被类名调用
			

			class Person {
				private String name;
				private int age;
				private static String country = "CN";
				Person(){};//无参数构造函数

				//一创建就有名字
				Person(String name){
					this.name = name;
				}
				Person(String name,int age){//一创建就有名字和年龄
					this(name);
					this.age = age;
				}
				public void speak(){
					System.out.println("name = "+name+"...age = "+age+"...country = "+country);
				}
			}
			class PersonDemo
			{
				public static void main(String[] args){
					Person p1 = new Person();
					p1.speak();
					Person p2 = new Person("HanMeimei",12);
					p2.speak();
					Person p3 = new Person("Lucy");//多个构造函数通过重载方式实现不同的初始化
					p3.speak();
				}
			}
			输出结果：
						name = null...age = 0...country = CN
						name = HanMeimei...age = 12...country = CN
						name = Lucy...age = 0...country = CN
			可以看到 static 变量 country 被所有的对象所共享

		2 成员变量和静态变量的区别？

			1. 两个变量的生命周期不同
				成员变量随着对象的创建而存在，随着对象被回收而释放。
				静态变量随着类的加载而存在，随着类的消失而消失。
	
			2. 调用方式不同
				成员变量只能被对象调用。
				静态变量可以被对象调用，还可以被类名调用。
		
			3. 别名不同
				成员变量也称为实例变量。
				静态变量也称为类变量。
		
			4. 数据存储位置不同
				成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
				静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

		3 注意事项：
			1 静态方法只能访问静态成员，如果访问非静态成员会报错。但是非静态方法既可以访问静态成员，
			也可以访问非静态成员。

				因为静态方法和变量存在的时候，对象还不存在，非静态变量也不存在，肯定无法访问

			2 静态方法中不可以写 this,super关键字
				原因：静态方法存在的时候，对象还不存在， this所代表的对象也不存在，肯定不能写在静态方法中

			3 主函数 main 是静态的，书写格式固定，被jvm识别和调用。

		4 静态什么时候用？
			1. 静态变量
				当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。
			只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
			如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。
			
			2. 静态函数
				函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。
			简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
			如果不需要，就可以将该功能定义成静态的。 当然，也可以定义成非静态，但是非静态需要被对象调用。
			如果没有访问特有数据的方法，该对象的创建是没有意义。

		5 静态代码块

			随着类的加载而执行，且只执行一次。
			作用：用于给类进行初始化

		 构造代码块
			
			作用：可以给所有对象进行初始化
			
				class Person {
					private String name;
					private static int age;
					private static String country ;
					Person(String name,int age){//一创建就有名字和年龄
						this.name =name;
					}
					//age = 10;//错误，初始化应该在在代码块中或者定义时进行
					
					//静态代码块，用于类初始化
					//静态代码块用于初始化类，所以非静态成员不能出出现在静态代码块
					static{
						age = 10;
					}
					//构造代码块，可用于所有对象进行初始化
					{
						age = 10;
						name = "haha";
					}
					public void speak(){
						System.out.println("name = "+name+"...age = "+age+"...country = "+country);
					}
				}