java面向对象（下篇）

成员变量与局部变量的区别：
    a：在类中的位置不同
        成员变量：在类中方法外。
        局部变量：在方法定义中或者方法声明上。
    b：在内存中的位置不同
        成员变量：在堆内存。
        局部变量：在栈内存。
    c：生命周期不同
        成员变量：随着对象的创建而存在，随着对象的消失而消失。
        局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
    d：初始化值不同
        成员变量：有默认的初始化值。
        局部变量：没有默认的初始化值，必须要定义，赋值，然后才能使用。
    注：局部变量名称可以和成员变量名称一样，在方法中使用的是就近原则。

当形式参数是引用类型时：

        示例代码如下：

class Student {
		public void show() {
			System.out.println("我爱学习");
		}	
	}

	class StudentDemo {
 		//此时调用的形式参数是一个引用类型（类类型），此时需要的应该是类的对象
		public void method(student s){      //调用时，应该把main方法中s的地址传递
			s.show();                       //到这里，Student s = new Student();
		}
	}

	public class ArgsTest {
		public static void main(String[ ] args) {
			StudentDemo sd = new StudentDemo ();
			//创建学生对象s
			Student s = new Student();
			sd.method(s);          //将s的地址传递到这里
		}
	}

匿名对象：
    匿名对象：就是没有名字的对象。
    匿名对象的应用场景：
        a：调用方法，仅仅只调用一次的时候，使用完毕后就是垃圾，可以被回收。
        b：可以作为实际参数传递

 

封装：
    概念：隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

    private :是一个权限修饰符，可以修饰成员变量和成员方法（被其修饰的成员只能在本类中被访问）

示例代码如下：

class Demo{
		//int num = 10;
		//用private修饰
		private int num = 10;       //用private调用后，不能被其他直接访问，但可以                                                                       
                                    //通过在本类中由本类中的方法调用，其他访问类中                                                                       
                                    //的方法，从而实现对private调用的量访问
		public void show(){
			System.out.println(num);
		}
	}

	class PrivateDemo{
		public static void main(String[ ] args){
			Demo d = new Demo();
			d.show();
		}
	}

注：被private封装的是一个方法，若实现不属于该类的访问，就需要在本类中重新建立一个方法，通过重新建立的方法对封装方法的调用，来实现对private封装的方法的调用。

类
    可以分为：成员变量，成员方法，构造方法

    构造方法：
        调用有返回值的方法时，返回值是什么类型，就定义一个该类型的变量
        进行接收，然后输出此变量。

在类中getXxx()与setXxx()方法的调用注意事项：

/*
 * 利用getXxx()和setXxx()进行赋值操作
 * 利用show()进行赋值操作
 * 
 * setName(String name){}  （）内需要进行传值，不然无法实现将主函数中的值传递给
 * 调用set方法的类中
 */
public class ClassDemo {
	public static void main(String[] args) {
		ClassDemo1 s = new ClassDemo1();
		s.setName("林青霞");       //给ClassDemo1中的name传值
		s.setAge(27);                   //给...............age传值
		System.out.println(s.getName()+"-------"+s.getAge());
	}                                         //将ClassDemo1中的name与age的值进行输出
}

class ClassDemo1{
	//定义变量姓名
	private String name;       //主函数不能直接调用和传递给name值
	//定义变量年龄
	private int age;
	
	public String getName() {
		return name;             //将name的值传递给主函数
	}
	
	public void setName(String name) {
		this.name = name;               //将主函数赋给name的值传给该类中的name 
	}	
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
}

ClassDemo1 s = new ClassDemo1();做的事情：
    a：把ClassDemo1.class文件加载到内存。
    b：在栈内存给s变量开辟一个空间。
    c：在堆内存为学生对象申请一个空间。
    d：给成员变量进行默认初始化。null  0
    e：给成员变量进行显示初始化。林青霞  27
    f：数据初始化完毕，然后把堆内存的地址值赋值给栈内存的s变量。

变量什么时候定义为成员变量：
    如果这个变量使用是描述这个类的信息的，那么，该变量就应该是成员变量。

    变量的范围越小越好，便于及时回收。

static:
    大量相同的成员变量被建立在堆内存中，造成对内存空间的浪费，进而引入了static

    static的特点：（可以修饰成员变量，还可以修饰成员方法）
        a：随着类的加载而加载  （main方法）
        b：优先于对象存在
        c：被类的所有对象共享
            若某个成员变量是被所有对象共享的，那么就应该将其定义为静态的
                举例：
                    饮水机（用静态修饰）
                    水杯（不能用静态修饰）
        d：可以通过类名调用
            其本身还可以通过对象名调用
    注：静态修饰的内容一般被称其为：与类相关的，类成员。

如以下代码：

class Student{
			static int num = 10;
		}

		class StudentDemo{
			public static void main(String[ ] args){
				Student s = new Student();
				System.out.println(s.num);    //通过对象调用
				//输出：10，通过类调用
				System.out.println(Student.num);
			}
		}

static关键字注意事项：
        a：在静态方法中是没有this关键字的
            理解：静态是随着类的加载而加载，this是随着对象的创建而存在
            静态比对象先存在
        b：静态方法只能访问静态的成员变量和静态的成员方法
            静态方法：
                成员变量：只能访问静态变量
                成员方法：只能访问静态成员方法
            非静态方法：
                成员变量：可以是静态的，也可以是非静态的
                成员方法：可以是静态的成员方法，也可以是非静态的成                员方法

            即：静态的只能访问静态的，非静态的的可以访问静态的和非静态的。

 

如以下代码：

class Teacher{
		public int num = 10;
		
		static int num2 = 20;

		public void show(){     //非静态成员方法
			System.out.println(num);         //隐含意思：访问的是成员变量
			System.out.println(this.num);   //明确告诉是成员变量 
			System.out.println(num2);     //非静态成员方法访问静态成员变量
		}

		public static void method(){  //静态成员方法
			System.out.println(num);      //num为非静态成员变量，会报错
		}
	}

静态变量和成员变量的区别：
        a：所属不同
            静态变量属于类，被称为类变量
            成员变量属于对象，被称为实例变量（对象变量）
        b：内存中位置不同
            静态变量存储于方法区的静态区
            成员变量存储于堆内存
        c：内存出现时间不同
            静态变量随着类的加载而加载，随着类的消失而消失
            成员变量随着对象的创建而存在，随着对象的消失而消失
        d：调用不同
            静态变量可以通过类名调用，也可以通过对象调用
            成员变量只能通过对象名调用