面向对象成员变量和局部变量，private--学习笔记--13

1.成员变量和局部变量区别
1.在类中位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
举例：

Class Demo  {
//成员变量（方法外）
Int num=10;
Public void show ( )  {
Int num2=20；//局部变量
}
}

2．在内存中位置不同
成员变量：在堆内存
局部变量：在栈内存
3.生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法调用完毕而消失
4. 初始化值不同
成员变量：有默认初始化值
局部变量： 没有默认初始化值，必须定义，赋值，然后才能使用
注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则

class Variable {
	 //int num=10;
	int num;
	 public void show() {
		 //int num2;//报错，可能尚未初始化。参照定义
		 int num2=20;
			System.out.println(num2);
	 }
}
class VariableDemo{
	public static void main(String[] args) {
		Variable v=new Variable();
		System.out.println(v.num);//访问成员变量
		v.show();
	}
  }

形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
形式参数是基本类型

class Demo{
	public int sum(int a,int b) {
		return a+b;
	}
}
//形式参数是引用类型,类是一个类型
class Student{
	public void show() {
		System.out.println("我爱学习");
	}
}
class StudentDemo{
	//如果看到一个方法的形式参数是一个类类型（引用类型），
	//这里其实需要的是该类的对象
	public void method(Student s) {//调用的时候，把main方法
		//中s的地址传递到这里，Student s=new Student
		s.show();
	}
}
class ArgsTest {
	public static void main(String[] args) {
		//形式参数是基本类型的调用
		Demo d=new Demo();
		int result=d.sum(10, 20);
    System.out.println(result);
    System.out.println("------------------");
  //形式参数是基本类型的调用
    //调用StudentDemo中method方法
    StudentDemo sd=new StudentDemo();
    Student s=new Student();
    sd.method(s);//把s的地址给到了这里
	}
}

匿名对象：就是没有名字的对象
应用场景：
1． 调用方法，仅仅只调用一次的时候。调用多次不适合
好处：匿名对象调用完后就是垃圾，可被回收
2． 匿名对象可以作为参数传递

3．	public void show() {
4．		System.out.println("我爱学习");
5．	    }
6．	  }
7．	class StudentDemo{
8．		public void method(Student s) {
9．			s.show();
10．			System.out.println("-------------");
11．	  }
12．	}
13．	 class NoNameDemo {  
14．		public static void main(String[] args) {		
15．			//带名字的调用
16．			Student s=new Student();
17．			s.show();
18．			
19．	//匿名对象
20．			new Student().show();
21．			System.out.println("-------------");
22．			StudentDemo sd=new StudentDemo();
23．		    //Student s1=new Student();
24．		    sd.method(new Student());
25．		}
26．	}

封装：
指隐藏对象的属性和实现细节，仅对外提供公共访问方式
原则：将不需要对外提供的内容都隐藏起来；
把属性隐藏，提供公共方法对其访问；

举例：定义一个学生类

• 成员变量：name age
• 成员方法：show()方法
• 我们在使用这个案例的过程中，发现一个问题
• 通过对象去给成员变量赋值，可以赋值一些非法的数据
• 这是不合理的，应该在赋值之前，先对数据进行判断
• 判断到底在哪里做比较合适呢？
• StudentDemo类是一个测试类，测试类一般只创建对象，调用方法
• 所以这个判断应该在Student中，而我们在成员变量的位置可不可以进行数据判断？
• 不可以，因为在数据校验必须要依靠一些逻辑语句，
• 逻辑语句应该定义在方法中，所以，我们最终在Student类中提供一个方法来进行数据校验
• 按照分析，我们给出了一个方法进行校验，但是它偏偏不调用方法赋值，还是直接赋值了
  这样我们的方法就没有起到作用
  我们应该要求必须使用方法，而不是直接调用成员变量赋值
  怎么强制要求不能直接使用成员变量呢
  针对这种情况，Java提供了一个关键字，private
  private:私有的，可以修饰成员变量和成员方法
  注意：被private修饰的成员只能在本类中访问

class Student{
String name;
 private int age;
//写一个方法来进行数据校验
//返回值类型 void(赋值操作，不需要返回值)

public void setAge(int a){
	if(a<0||age>110) {
		System.out.println("年龄有误");
	}else {
		age=a;
	}
}


public void show() {
	System.out.println("姓名 "+name);
	System.out.println("年龄 "+age);
	}
  }

class StudentDemo {
	public static void main(String[] args) {
		Student s=new Student();
		s.show();
		System.out.println("-------------");
		s.name="林青霞";
		s.setAge(27);
		s.show();
		System.out.println("-------------");
		//s.age=-27;
		s.setAge(-27);
		s.show();
	}
}

Private关键字
(1)是一个权限修饰符
(2)可以修饰成员（成员变量和成员方法）
(3)被private修饰的成员只在本类中才能访问
(4)最常见的应用
是成员变量用private修饰；
提供对应的getXx()/setXx()方法一个标准案例的使用；

class Student{
	private String name;
	private int age;
	//姓名获取值
	public String getName() {
	return name;
	}
	//年龄获取值
	public int getAge() {
		return age;
	}
	//年龄设置值
	public void setAge(int a) {
		age=a;
		}
	//姓名设置值
	public void setName(String n) {
		name=n;
	}
}
	//测试类
public class StudentTest {
public static void main(String args[]) {
	Student s=new Student();
	s.setAge(20);
    s.setName("易烊千玺");
	System.out.println(s.getAge()+"--"+s.getName());
}
}