Java学习笔记⑤(面向对象中的构造方法和标准的类)

一、面向对象

面向过程:当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

面向对象:当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

public class Demo01PrintArray {
	public static void main(String[] args) {
	//要求打印格式为:[10，20，30，40，50]
	//使用面向过程，每个步骤细节都要亲力亲为。
		System.out. print("[")；
		for (int i =0;i<array.length;i++) {
			if( i == array.length-1) {
			//如果是最后一个元素
			System.out.println(array[i]+"]");
			} else {//如果不是最后一个元素
			System.out.print(array[i] +",");
			}
		}
		System.out.println("==========");
		//使用面向对象
		//找一个JDK给我们提供好的Arrays类
		//其中有一个tostring方法，直接就能把数组变成想要的格式的字符串
System.out.printIn(Arrays.tostring(array));
	}
}

定义一个类，用来模拟“学生"事物。其中就有两个组成部分：

• 属性(是什么)：
  姓名
  年龄
• 行为(能做什么)：
  吃饭
  睡觉
• 对应到Java的类当中：
  成员变量(属性)：
  String name; //姓名
  int age; //年龄
  成员方法(行为)：
  public void eat{} 吃饭
  public void sleep{} 睡觉
  public void study{} 学习

注意事项：
成员变量是直接定义在类当中的，在方法外边。
成员方法不要写static关键字。

• 通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

1. 导包：也就是指出需要使用的类，在什么位置。
   import 包名称.类名称;
   import cn.itcast.day06.demo01.Student;
   对于和当前类属于同一个包的情况，可以省略导包语句不写。
2. 创建，格式：
   类名称 对象名 = new 类名称();
   student.stu = new Student();
3. 使用，分为两种情况：
   使用成员变量：对象名.成员变量名
   使用成员方法：对象名.成员方法名(参数)
   (也就是，想用谁，就用对象名点儿谁)

注意事项:
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

一个对象的内存图：

两个对象使用同一个方法的内存图：

两个引用指向同一个对象的内存图：

使用对象类型作为方法的参：

使用对象类型作为方法的返回值：

局部变量和成员变量：

1. 定义的位置不一样【重点】
   局部变量：在方法的内部
   成员变量：在方法的外部，直接写在类当中
2. 作用范围不一样【重点】
   局部变量：只有方法当中才可以使用，出了方法就不能再用成员变量：整个类全都可以通用
3. 默认值不一样【重点】
   局部变量：没有默认值，如果要想使用，必须手动进行赋值
   成员变量：如果没有赋值，会有默认值，规则和数组一样
4. 内存的位置不一样(了解）
   局部变量：位于栈内
   成员变量：位于堆内存
5. 生命周期不一样（了解）
   局部变量：随着方法进栈而诞生，随着方法出栈而消失
   成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

面向对象的三大特征：
封装、继承、多态。

封装性在Java中的体现：

1. 方法就是一种封装
2. 关键字private也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见

 public class Demo02Method {
 	public static void main(String[] args) { 
 		int[] array = {5, 15 ,25 ,20 ,100 };
 		int max = getMax(array);				
 		System.out.println("最大值："+max);
 	}
 	//给我一个数组，我换给你一个最大值
	public static int getMax(int[] array) {
		int max =array[0];
		for (int i=1;i<array.length;i++) {
			if (array[i]> max) {
				max=array[i];
			}
		}
		return max;
	}
}

private关键字的作用及使用：

• 一旦使用了private进行修饰，那么本类当中仍然可以随意访问，但是超出了本类范围之外就不能再直接访问了。
• 间接访问private成员变量，就是定义一对儿Getter/ Setter方法，必须叫sseXxx或者是getXxx命名规则。
• 对于Getter来说，不能有参数，返回值类型和成员变量对应；
• 对于Setter来说，不能有返回值，参数类型和成员变量对应。

this关键字的作用：

• 当方法的局部变量和类的成员变量重名的时候，根据"就近原则"，优先使用局部变量。
• 如果需要访问本类当中的成员变量，需要使用格式:
  this.成员变量名
• “通过谁调用的方法，谁就是this。”

构造方法：
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

• 格式：
  public 类名称(参数类型 参数名称) {
  方法体
  }

• 注意事项：

1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2. 构造方法不要写返回值类型，连void都不写
3. 构造方法不能return一个具体的返回值
4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。public Student（）{}
5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。
6. 构造方法也是可以进行重载的。
   重载：方法名称相同，参数列表不同。

标准的类：
一个标准的类通常要拥有下面四个组成部分：

1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对儿Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法

这样标准的类也叫做Java Bean。

public class Student {
	private String name;//姓名
	private int age;//年龄
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this name = name;
	}
	
	public int getAge () {
		return age;
	}
	
	public void setAge(int age) {
		this age = age;
	}
}

package cn.itcast.day06.demo05;

public class Demo01Student {
	public static void main(String[] args) {
	Student stu1 = new Student();
	stu1.setName("迪丽热巴");
	stu1.setAge(20);
	System.out.println("姓名："+stu1.getName()+"，年龄："+stu1.getAge());
	System.out.println("==========");
	
	Student stu2=new Student("古力娜扎",21);
	System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());
	stu2.setAge(22);
	System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());
	System.out.println("==========");
	}
}