java-成员变量与局部变量，封装

1.面向对象的进阶

---

1.1成员变量和局部变量的区别

---

//成员变量和局部变量的区别
//1.在类中的位置不同
//	成员变量:类中方法外
//	局部变量:在方法中定义的变量(方法里面，方法声明中)
//2.作用的范围不同
//	成员变量:类中可以使用(成员方法)
//	局部变量:只有在定义该变量的方法中使用
//3.在内存中的位置不同
//	成员变量:在堆内存
//	局部变量:在栈内存
//4.初始化值不同
//	成员变量:有默认的初始化
//	局部变量:没有默认的初始值，必须定义后赋值再使用
//5.生命周期不同
//	成员变量:随着对象的创建而存在，随着对象的销毁而销毁
//	局部变量:随着方法的调用而存在，随着方法的调用完毕而消失
//注意事项:局部变量的名称可以和成员变量的名称一样 就近原则(先找方法中是否存在局部变量然后再找成员变量)

class Variable{
	//成员变量
	int num;//0
	int num2=99;
	//成员方法
	public void show(){
		//局部变量
		int num2=20;
		System.out.println(num);
		//就近原则(先找方法中是否存在局部变量然后再找成员变量)
		System.out.println(num2);
	}
	public void show2(int num3){
		System.out.println(num);
		//System.out.println(num2);报错的 num2只能在show方法使用
	}
}

public class VariableDemo{
	public static void main(String[] args){
		Variable variable=new Variable();
		System.out.println(variable.num);//0
		variable.show();
	}
}

1.2对象的垃圾回收

---

2.方法

---

2.1为什么需要方法

---

public class MethodDemo01{
	public static void main(String[] args){
		int x=10;
		int y=20;
		//相加
		int c=x+y;
		//输出结果
		System.out.print(c);
		//60+80
		int x2=60;
		int y2=90;
		int c2=x2+y2;
		System.out.println(c2);

		//重复编写代码!!!
		//把这些重复的代码放到一地方，只需要写一次代码，方法
	}
}

2.2方法的定义格式

---

方法:完成特定功能的代码块

方法的定义格式:
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2){
	//代码
	return返回值;
}
返回值类型:就是功能结果的数据类型
参数:形成参数 就是定义在方法声明中,用于接受实际参数
实际参数:就是实际参与运算的值
return:结束方法的
返回值:就是功能的运算的结果，用return带给调用者

2.3有参数,没有返回值

---

class Number{
	//需求:我给你两个数 两个整数相加，打印出来
	//定义一个方法的时候:两个明确
	//A:返回值类型 结果的数据类型
	//B:参数列表 你要传递几个参数，以及每个参数的类型
	//成员方法
	public void sum(int a,int b){
		int c=a+b;
		System.out.println(c);
		//return;
		//结束方法的 如果一个方法返回值类型为void,return可以不写
	}
}

public class NumberDemo{
	public static void mian(String[] args){
		Number number=new Number();
		number.sum(1,2);
		number.sum(1,5);
		number.sum(1,8);
	}
}

2.4有参数，有返回值

---

需求:两个整数相加，你把结果给我

class Number{
	//需求:我给你两个数 两个整数相加，打印出来
	//定义一个方法的时候:两个明确
	//A:返回值类型 结果的数据类型
	//B:参数列表 你要传递几个参数，以及每个参数的类型
	//成员方法
	public void sum(int a,int b){
		int c=a+b;
		System.out.println(c);
		//return;
		//结束方法的 如果一个方法返回值类型为void,return可以不写
	}
	//需求:两个整数相加，你把结果给我
	//返回值类型 int
	//参数列表 两个int类型的参数
	public int sum2(int a,int b){//int a=1;int b=2
	int c=a+b;//3
	return c;//3
	}
}

public class NumberDemo{
	public static void main(String[] args){
		Number number=new Number();
		//方式1:单独调用
		number.sum2(1,2);
		//方式2:赋值调用
		//int result=3;
		int result=number.sum2(1,2);
		System.out.println(result);
		//方式3:输出调用
		System.out.println(number.sum2(1,2));
	}
}

2.5没有参数，有返回值

---

//没有参数，有返回值
public int sum3(){
	return 100;
}

2.6没有参数，有返回值

---

public void hello(){
	System.out.println("hello world!");
}

main

	Number number=new Number();
	//如果一个方法没有返回值，智能进行单独调用
	number.hello();

2.7获取两个数的最大值

---

class Number{
	//获取两个整数的最大值
	//两个明确
	//返回值类型 int类型
	//参数列表 两个参数
	public int getMax(int a,int b){
		//int a=1 int b=2
		if(a>b){
			return a;
		}else{
			return b;
		}
	}
}

public class NumberDemo{
	public static void main(String[] args){
		Number number=new Number();
		System.out.println(number.getMax(1,2));
	}
}

优化

public int getMax(int a,int b){
	int c=(a>b)?a:b;
	return c;
}

再次优化

public int getMax(int a,int b){
	return (a>b)?a:b;
}

2.8判断两个整数是否相等

---

/*
判断两个整数是否相等
两个明确
返回值类型 boolean
参数列表 两个int类型
*/
public boolean compare(int a,int b){
	if(a==b){
		return true;
	}else{
		return false;
	}
}

优化

public boolean compare(int a,int b){
	return a==b?true:false;
}

再优化

public boolean compare(int a,int b){
	return a==b;
}

2.9方法的注意事项

---

1. 方法不调用不执行
2. 方法和方法是平级关系，不能嵌套定义
3. 方法定义的时候参数用，隔开
4. 方法调用的时候不需要在传递数据类型
5. 如果方法有明确的的返回值类型，一定要有return带回一个值
6. 当方法的返回值类型是void，只能单独调用

3.方法的高级应用

---

3.1方法的参数维数组

---

需求:传递一个int类型数组，获取数组的最大值
两个明确;
返回值类型int
参数列表:int[] arr

class Number{
/**
* 获取数组的最大值
* @param arr 传递一个数组 * @return 返回数组的最大值
*/
	public int getArrayMax(int[] arr) {
		int max=arr[0];
		for(int i=1;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
		}
		return max;
	}
}

public class NumberDemo {
	public static void main(String[] args) {
		Number number=new Number();
		System.out.println(number.getMax(1, 2));
		System.out.println(number.compare(3, 3));
		int[] arr= {1,2,3,4,5,6,7,8,9};
		int max=number.getArrayMax(arr);
		System.out.println(max);
	}
}

3.2方法的调用栈

---

class Stack{
	public void hello(){ 
		System.out.println("hello方法的开始");
		aa(100); 
		System.out.println("hello方法的结束");
		ee();
	}
	public int aa(int a){ 
		System.out.println("aa开始");
		bb();
		System.out.println("aa结束");
		dd();
		return 100;
	}
	public void bb(){ 
		System.out.println("bb开始");
	}
	//hello方法的开始 aa开始 "bb开始 aa结束 dd开始	hello方法的结束 ee开始
	public void dd(){
	 System.out.println("dd开始");
	}
	public void ee() { 
		System.out.println("ee开始");
	}
}
public class StackDemo {
	public static void main(String[] args) {
		Stack stack=new Stack();
		stack.hello();
	}
}

3.3方法的重载

---

class Number2{
	//我们在实现各种组合的相加，方法的名字不一样 //我们要求见名知意
	//怎么办呢? 
	//针对这种情况，方法的功能相同,参数列表不同，为了见名知意
	//Java允许他们的名字一样	专业名词:方法的重载
	//在一个类中,方法名相同，参数列表不同(参数的类型和个数)。与返回值没有关系
	
	//两个整数相加
	public int add(int a,int b) {
		return a+b;
	}
	//两个整数相加
	public int add(int a,long b) {
		return 3;
	}
	//三个整数相加
	public int add(int a,int b,int c) {
		return a+b+c;
	}
}

public class NumberDemo02 {
	public static void main(String[] args) {
		Number2 number=new Number2();
		System.out.println(number.add(1, 2));//3
		System.out.println(number.add(1, 2L));
		System.out.println(number.add(1,2,3));
		//什么叫做方法的重载?		
		//在一个类中 
		//方法的名字相同，参数列表不同(参数的类型和个数),与返回值类型无关
	}
}

4.封装

---

面向对象的三大特性:封装 继承 多态
封装:指隐藏对象的属性和实现细节，仅对外提供公共的访问方式

4.1封装的概念

class Student2{
	String name;
	//成员变量可以直接进行赋值,可以进行一些非法操作 
	//在赋值之前，可以先判断一下，在哪里判断? 
	//逻辑代码必须放在方法中 
	//我们就在Student2写一个方法给age赋值 
	//age属性不能直接赋值
	//java提供一个关键字 private(私有的)
	private int age;
	//private 私有的，可以修饰成员变量和成员方法 
	//被private修饰的成员只能在本类中访问 
	//封装:指隐藏对象的属性和实现细节,仅对外提供公共的访问 
	//我们就在Student2写一个方法给age赋值
	public void setAge(int a) {
		if(a<0||a>120) { 
			System.out.println("你的年龄有问题!");
		}else{
			//局部变量的值赋值给成员变量
			age=a;
			}
		}
	public void show() { 
		System.out.println("名字:"+name); 
		System.out.println("年龄:"+age);
	}
	private void sleep() { 
		System.out.println("睡觉");
	}
}
public class StudentDemo02 {
	public static void main(String[] args) {
		Student2 student2=new Student2();
		student2.name="班长";
		student2.setAge(99);
		student2.show();
	}
}

4.2private 特点

---

//private 权限修饰符 可以修饰成员变量和成员方法 
//被它修饰的成员只能在本类中访问
class PrivateDemo{
	private int num=10;
	public void show() { 
	//本类中的方法可以访问私有属性的
	System.out.println(num);
	}
	private void method() {
		System.out.println("method");
	}
	public void function() { 
		//本类中的方法可以访问私有的方法
		method();
	}
}

public class PrivateDemoTest {
	public static void main(String[] args) {
		PrivateDemo privateDemo=new PrivateDemo();
		privateDemo.show();
		privateDemo.function();
	}
}

4.3private的标准案例

---

class Person{
	//姓名
	private String name;
	//年龄
	private int age;
	//地址
	private String address;
	//设置值是设置名字
	public void setName(String n) {
		//不写判断 引出封装的概念	以后判断有其它的方式
		name=n;
	}
	//获取名字
	public String getName() {
		return name;
	}
	//设置年龄
	public void setAge(int a) {
		age=a;
	}
	//获取年龄
	public int getAge() {
		return age;
	}
	//设置地址
	public void setAddress(String a) {
		address=a;
	}
	//获取值
	public String getAddress() {
		return address;
	}
}
public class PersonDemo {
	public static void main(String[] args) {
		Person person=new Person();		
		System.out.println("name:"+person.getName()+"age:"+person.getAge()+"address"+person.getAddr
ess());
		//赋值 person.setName("副班长");
		person.setAge(18); person.setAddress("地球");
		System.out.println("name:"+person.getName()+"age:"+person.getAge()+"address"+person.getAddr
	ess());
	}
}