类与对象（上）（封装性）

一.面向对象
1概述：
面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的模块，来实现。
面向对象的特征：封装、继承、多态
封装性在Java中体现：（封装就是一些具体细节隐藏起来，对于外界不可见。）
1>方法是一种封装
2>关键字private就是一种封装

import java.util.Arrays;
/*
 * 面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节
 * 面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的模块，来实现。
 * 面向对象的特征：封装、继承、多态
 */

public class Demo01PrintArray {
	public static void main(String[] args) {
		//使用面向过程
		
		int[] arr = { 10, 20, 30, 40, 50 };
		// 打印格式为[10,20,30,40,50]
		// 使用面向过程
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			// 如果是最后一个元素
			if (i == arr.length - 1) {
				System.out.print(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ", ");
			}
		}
		System.out.println();
		//使用面向对象
		//找到JDK提供的Arrays类提供的toString方法，直接将数组变成想要格式的字符串
		System.out.println(Arrays.toString(arr));
		
	}
}

运行结果：

1.2类与对象
什么是类？
——类是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事务。
属性：该事物的状态信息。如：名字、年龄。
行为：该事物的动作。如：走、跑。
什么是对象？
对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必须具备该类事务的属性和行为。
现实中，一类事物的一个实例：一只小猫。
总之，类是抽象的，对象是具体的。类是对象的模板，对象是类的具体实例。
3类和对象的创建与使用

//注意事项：
//1.成员变量是直接定义在类当中，在方法外边。
//2.成员方法不能写static关键字。
/*
 * 通常情况下，一个类并不能直接使用，需要创建一个对象，才能使用。
 * 
 * 1.导包：指出需要使用的类在什么位置。
 * import 包名称.类名称
 * 对于和当前类属于同一个包的情况，可以省略导包语句不写。
 * 
 * 2.创建对象格式：
 * 类名称 对象名=new 类名称（）；
 * Studnet stu=new Student();
 * 
 * 3.使用分两种情况：
 * 使用成员变量：		对象名.成员变量名
 * 使用成员方法：		对象名.成员方法名（参数）
 */
public class Student {
	//成员变量
	String name;
	int age;
	//成员方法
	public void eat() {
		System.out.println("吃饭");
	}
	public static void main(String[] args) {
		Student stu=new Student();
		System.out.println(stu.name);//默认值：null
		System.out.println(stu.age);//默认值：0
		System.out.println("====================");
		//改变对象当中成员变量的内容
		stu.name="LiHua";
		stu.age=18;
		System.out.println(stu.name);
		System.out.println(stu.age);
		System.out.println("====================");
		//使用对象的成员方法
		stu.eat();
	}
}

运行结果：

练习：

/*
 * 定义一个类，用来说明手机事物。
 * 属性：品牌、价格、颜色
 * 行为：打电话、发短信
 * 
 * 对应到类中：
 * 成员变量（属性）：
 * String brand;//品牌
 * double price;//价格
 * String color;//颜色
 * 成员方法：
 * public void call(String who)//打电话
 * public void sendMessage()//群发短信
 */
public class Demo01PhoneOne {
	//成员变量
	String brand;
	double price;
	String color;
	//成员方法
	public void call(String who) {
		System.out.println("给"+who+"打电话");
	}
	public void sendMessage() {
		System.out.println("群发短信");
	}
	public static void main(String[] args) {
		//创建对象
		Phone phone=new Phone();
		System.out.println(one.brand);//null
		System.out.println(one.price);//0.0
		System.out.println(one.color);//null
		System.out.println("==================");
		
		phone.brand="苹果";
		phone.price=8388.0;
		phone.color="黑色";
		System.out.println(one.brand);//null
		System.out.println(one.price);//0.0
		System.out.println(one.color);//null
		
		System.out.println("==================");
		phone.call("乔布斯");
		phone.sendMessage();
	}
}

运行结果：

内存分布图：

4.使用对象类型作为方法的参数

package javase_online;

public class PhoneParamDemo {
	// 成员变量
	String brand;
	double price;
	String color;

	// 成员方法
	public void call(String who) {
		System.out.println("给" + who + "打电话");
	}

	public void sendMessage() {
		System.out.println("群发短信");
	}

	public static void main(String[] args) {
		Phone one = new Phone();
		one.brand = "苹果";
		one.price = 8388.0;
		one.color = "土豪金";
		method(one);// 传进去的参数其实就是地址
	}

	public static void method(Phone param) {
		System.out.println(param.brand);
		System.out.println(param.price);
		System.out.println(param.color);
	}
}

运行结果：

内存分布图：

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

package javase_online;

public class Demo05PhoneReturn {
	// 成员变量
	String brand;
	double price;
	String color;

	// 成员方法
	public void call(String who) {
		System.out.println("给" + who + "打电话");
	}

	public void sendMessage() {
		System.out.println("群发短信");
	}

	public static void main(String[] args) {
		Phone two = getPhone();
		System.out.println(two.brand);
		System.out.println(two.price);
		System.out.println(two.color);
	}

	public static Phone getPhone() {
		Phone one = new Phone();
		one.brand = "苹果";
		one.price = 8388.0;
		one.color = "玫瑰金";
		return one;
	}
}

运行结果：

内存分布图：

6.成员变量和局部变量区别
package javase_online;

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

	public void methodA() {
		int num = 20;// 局部变量
		System.out.println(num);
		System.out.println(name);
	}

	public void methodB(int param) {// 方法的参数就是局部变量*********
		// 参数在方法调用的时候，必然会被赋值
		System.out.println(param);
		int age;
		System.out.println(age);// 错误写法,局部变量必须赋值方可使用
		System.out.println(name);
	}
}

7.关键字private应用
package javase_online;

/*
 * 对于基本类型中的boolean值，Getter方法一定要写成isXXX形式，而setXXX规则不变
 */
class Students {
	private String name;// 姓名
	private int age;// 年龄
	private boolean male;// 是否为男

	public void setMale(boolean b) {
		male = b;
	}

	public boolean isMale() {
		return male;
	}

	public void setName(String str) {
		name = str;
	}

	public String getName() {
		return name;
	}

	public void setAge(int num) {
		age = num;
	}

	public int getAge() {
		return age;
	}

}

public class StudentDemo {
	public static void main(String[] args) {
		Students stu = new Students();

		stu.setName("LuHan");
		stu.setAge(20);
		stu.setMale(true);

		System.out.println("姓名：" + stu.getName());
		System.out.println("年龄：" + stu.getAge());
		System.out.println("是否为男：" + stu.isMale());
	}
}

运行结果：

8.关键字this应用

package javase_online;

/*
 * 当方法的局部变量和类的成员变量重名的时候，根据“就近原则"，优先使用局部变量。
 * 如果需要访问本类当中的成员变量，需要使用格式：
 * this.成员变量名
 */
//通过谁调用的方法，谁就是this，this是person
public class Person {
	String name;// 我自己的名字

	// 参数name是对方的名字
	// 成员变量name是自己的名字
	public void sayHello(String name) {
		System.out.println(name + ",你好，我是" + this.name);
		System.out.println(this);// 地址值
	}

	public static void main(String[] args) {
		Person per = new Person();
		// 设置自己的名字
		per.name = "李明";
		per.sayHello("小花");
		System.out.println(per);// 地址值
	}
}

运行结果：

9.static应用

public class Demo01StaticField {
	/**
	 * 如果一个成员变量使用了static关键字，那么这个成员变量不再属于自己，而是属于所在的类，多个对象共享同一份数据。
	 */
	public static void main(String[] args) {
		Student one = new Student("郭靖", 19);
		one.room = "101";
		System.out.println("姓名:" + one.getName() + ",年龄：" + one.getAge() + ",教室:" + one.room + ",学号" + one.getId());
		Student two = new Student("黄蓉", 16);
		System.out.println("姓名:" + two.getName() + ",年龄：" + two.getAge() + ",教室:" + two.room + ",学号" + two.getId());
	}
}
//
public class Student {
	private String name;//姓名
	private int age;//年龄
	static String room;//所在教室
	private int id;//学号
	private static int idCounter=0;//学号计数器，每当new了一个新对象时，计数器++
	public Student() {
		this.id=++idCounter;
	}
	public int getId() {
		return id;
	}
	public void setId() {
		this.id=id;
	}
	public Student(String name,int age) {
		this.name=name;
		this.age=age;
		this.id=++idCounter;
	}
	public String getName() {
		return name;
	}
	public void setNmae() {
		this.name=name;
	}
	public int getAge() {
		return age;
	}
	public void setAge() {
		this.age=age;
	}
}

运行结果：

/*
 * 一旦使用static修饰成员方法，那么这就成了静态方法，静态方法不属于对象，而是属于类的。
 * 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
 * 如果有static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
 * 
 * 无论是成员变量，还是成员方法，如果有了static，都推荐使用类名称进行调用。
 * 静态变量：类名称.静态变量
 * 静态方法：类名称.静态方法（）
 * 
 * 注意事项：
 * 1.静态不能直接访问非静态
 * 原因：内存中先有静态内容，后有非静态内容。
 * 2.静态方法中不能写this
 * 原因：this代表当前对象，通过谁调用的方法，谁就是当前对象，但是对象和静态没关系，
 */
public class Demo02StaticMethod {
	public static void main(String[] args) {
		MyClass obj = new MyClass();// 首先创建对象
		obj.method();

		// 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用
		obj.methodStatic();// 正确，不推荐.这种写法在编译之后也会被javac编译成“类名称.静态方法名”
		MyClass.methodStatic();// 正确，推荐

		// 对于本类当中的静态方法，可以省略类名称
		myMethod();
	}

	public static void myMethod() {
		System.out.println("自己的方法");
	}
}
==========================================================================================
public class MyClass {
	int num;// --成员变量
	static int numStstic;// --静态变量

	// 成员方法
	public void method() {
		System.out.println("这是一个成员方法");
	}

	// 静态方法
	public static void methodStatic() {
		System.out.println("这是一个静态方法");
	}

}

运行结果：

/*
 * 静态代码块的格式是;
 * public class 类名称{
 * static{
 *		//静态代码块内容
 *		}
 *}
 *
 *特点：当第一次用到本类时，静态代码块执行唯一的一次。
 *静态内容总是优先于非静态。所以静态代码块比构造方法先执行。
 *
 *静态代码块的典型用途，用来一次性地对静态成员变量进行赋值。
 *
 */
public class Demo04Static {
	public static void main(String[] args) {
		Person one = new Person();
		Person two = new Person();
	}
}
//
public class Person {
	static {
		System.out.println("静态代码块执行");
	}
	public Person() {
		System.out.println("构造方法执行");
	}
}

运行结果：

10.构造方法

/*
 * 构造方法是专门用来创建对象的方法，当我们通过new关键字来创建对象时，其实就是在调用构造方法。
 * 格式：
 * public 类名 （参数类型 参数名称）{
 * 方法体
 * }
 */
/*
 * 注意事项：
 * 1.构造方法的名称必须和所在的类名称完全一样，就连大小写一样
 * 2.构造方法无返回值类型
 * 3.构造方法不能return一个具体的返回值
 * 4.如果没有编写任何构造方法，则编译器会默认赠送一个构造方法，没有参数，方法体什么事情都不做。
 * public Student(){   }
 * 5.一旦编写了至少一个构造方法，那么编译器不再赠送
 * 6.构造方法也可以进行重载：方法名称相同，参数列表不同
 */

public class Student {

   public Student() {
   	System.out.println("构造方法在执行");
   }
   public static void main(String[] args) {
   	Student stu=new Student();
   }
}

运行结果：

 public class Student {
	private String name;
	private int age;
	public Student(String name,int age) {
		this.name=name;
		this.age=age;
		System.out.println("有参构造方法在执行");
		System.out.println("name="+name+",age="+age);
	}
	public Student() {
		System.out.println("无参构造方法在执行");
	}
	public static void main(String[] args) {
		Student stu=new Student("LiMing",18);
	}
}

运行结果：

public class Student {
	private String name;
	private int age;
	public Student(String name,int age) {
		this.name=name;
		this.age=age;
		System.out.println("有参构造方法在执行");
		System.out.println("name="+name+",age="+age);
	}
	public Student() {
		System.out.println("无参构造方法在执行");
	}
	public static void main(String[] args) {
		Student stu1=new Student();
		System.out.println();
		Student stu2=new Student("LiMing",18);
	}
}

运行结果：

public class Student {
	private String name;
	private int age;
	public Student(String name,int age) {
		this.name=name;
		this.age=age;
		System.out.println("有参构造方法在执行");
		System.out.println("name="+name+",age="+age);
	}
	public Student() {
		System.out.println("无参构造方法在执行");
	}
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age=age;
	}
	public int getAge() {
		return age;
	}
	public static void main(String[] args) {
		Student stu1=new Student();
		System.out.println();
		Student stu2=new Student("LiMing",18);
		System.out.println("姓名;"+stu2.getName()+"，年龄："+stu2.getAge());
		//如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXXX方法
		stu2.setAge(21);
		System.out.println("姓名;"+stu2.getName()+"，年龄："+stu2.getAge());
	}
}

运行结果：

11.定义一个标准的类
package ch16;

/*

• 一个标准的类通常由下面四部分组成：
• 1.所有的成员变量都要使用private关键字修饰
• 2.为每个成员变量编写一对Setter、Getter方法
• 3.编写一个无参构造方法
• 4.编写一个有参构造方法
• 这样标准的类也叫做Java Bean
  */

public class Student {
   private String name;// 姓名
   private int age;// 年龄

   public Student() {

   }

   public Student(String name, int age) {
   	this.name = name;
   	this.age = 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;
   }

   public static void main(String[] args) {
   	Student stu1 = new Student();
   	stu1.setName("LiMing");
   	stu1.setAge(18);
   	System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge());
   	System.out.println("====================");
   	Student stu2 = new Student("ZhangHong", 19);
   	System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
   }
}

运行结果：