Java开发入门之第一阶段（十二）——面向对象

面向对象思想的概述

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲历亲为，详细处理每一个细节
面向对象：当需要实现一个功能的时候，不关心具体过程，而是找一个已经具有该功能的人，来帮我做事。

public class Demo1 {

	public static void main(String[] args) {
		
		int[] array = {10,20,30,40,50};
		
		//要求打印格式为{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("=================");
		
		//使用面向对象
		System.out.println(Arrays.toString(array));
	}

}

//找一个JDK给我们提供好的Arrays类
//其中有一个toString方法，直接就能把数组变成想要的格式的字符串
代码案例展示出，面向对象比面向过程更简单，更方便。

面向对象思想的举例

类会如对象的关系

环顾四周，你会发现很多对象，比如，桌子、椅子、同学、老师等。桌椅属于办公用品，师生是人类。那么什么是类呢？什么是对象呢？

什么是类

• 类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来面鼠该类事物。

现实中，描述一类事物：

• 属性：就是该事物的状态信息。
• 行为：就是该事物能够做什么

举例：小猫
属性：名字，体重，年龄，颜色
行为：走，跑，叫

什么是对象

• 对象：是一类事物的具体体现。对象是一个类的实例（对象可不是找女朋友，也不是象棋里的对象），必然具备该类事物的属性和行为。
  现实中，一类事物的一个实例：一只小猫。
  举例：一只小猫
  属性：tom，5kg，2years，yellow
  行为：爬着墙角走，蹦跶的跑，喵喵叫

类和对象的关系

• 类是一类事物的描述，是抽象的
• 对象是一类事物的实例，是具体的
• 类是对象的模板，对象是类的实体

类的定义

事物与类的对比

现实世界的一类事物：
属性：事物的状态信息
行为：事物能够做什么

Java中用class描述事物也是如此：
成员变量：对应事物的属性
成员方法：对应事物的行为

类的定义格式

public class ClassMate{
		//成员变量
		//成员方法
	}

举例模拟一下：

package 面向对象;
/*
 * 定义一个类，用来模拟“学生”事物，其中就有两个二组成部分：
 * 属性：（是什么）
 * 		姓名
 * 		年龄
 * 行为：（能做什么）
 * 		吃饭
 * 		睡觉
 * 		学习
 * 
 * 对应到Java的类当中
 * 
 * 成员变量（属性）：
 * 		Strint name;//姓名
 * 		int age;//年龄
 * 成员方法（行为）：
 * 		public void eat() {}//吃饭
 * 		public void sleep() {}//睡觉
 * 		public void study() {}//学习
 */
public class Student {
	//成员变量
	String name;//姓名
	int age;//年龄
	//成员方法
	public void eat() {
		System.out.println("吃饭饭");
	}
	public void sleep() {
		System.out.println("睡觉觉");
	}
	public void study() {
		System.out.println("学习！");
	}
}

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

对象的创建及其使用

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

1. 导包：也就是指出需要使用的类，在什么位置

import 包名称.类名称；
其中import是关键字。
对于和当前类属于同一个包的情况，可以省略导包语句不写。

2.创建格式：
类名称 对象名 = new 类名称（）；
Student stu = new Student（）；

3.使用，分两种情况：

• 使用成员变量：对象名.成员变量名
• 使用成员方法名：对象名.成员方法名（参数）
• （也就是，想用谁，就用对象点er谁）
  下面的例子里的student类是上面的代码

public class Demo02Student {

	public static void main(String[] args) {
		//1.导包
//		我需要使用student类，和我自己Demo02Student位于同一包下，所以省略导包语句不写
//		2.创建格式
//		类名称  对象名 = new 类名称（）
//		根据Student类，创建一个名为stu的对象
		Student stu = new Student();
		
//		3.使用其中成员变量，格式：对象名.成员变量名
		System.out.println(stu.name);
		System.out.println(stu.age);
		
//		改变对象当中的成员变量数值内容
//		将右侧的字符串赋值交给stu对象当中的那么成员变量
		stu.name="赵丽颖";
		stu.age=18;
		System.out.println(stu.name);
		System.out.println(stu.age);
		System.out.println("==========");
		
//		4.使用对象的成员方法，格式：
//		对象名.成员方法名（）;
		stu.eat();
		
	}

}

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

手机类练习

Phone类

/*
 * 定义一个类，用来模拟“手机事物”
 * 属性：品牌、价格、颜色
 * 行为：打电话、发短信
 * 
 * 对应到类当中：
 * 成员变量（属性）：
 * 		String brand;//品牌
 * 		double price;//价格
 * 		String color;//颜色
 * 成员方法（行为）：
 * 	public void call(String who){} //打电话
 * public void sendMessage() {}//发短信
 */
public class Phone {

		// 成员变量
		String brand;//品牌
		double price;//价格
		String color;//颜色
		
		//成员方法
	public void call(String who) {
		System.out.println("给" + who + "打电话");
	}
	public void sendMessage() {
		System.out.println("群发短信");
	}

	

}

phone的one对象：

public class PhoneOne {

	public static void main(String[] args) {
		//根据Phone类，创建一个名为one的对象
		//格式：类的名称 对象名 = new 类名称（）；
		Phone one =new Phone();
		System.out.println(one.brand);//null
		System.out.println(one.price);//0.0
		System.out.println(one.color);//null
		System.out.println("=================");
		
		one.brand = "华为";
		one.price = 8868.0;
		one.color = "淡橘色";
		System.out.println(one.brand);//华为
		System.out.println(one.price);//8868.0
		System.out.println(one.color);//淡橘色
		System.out.println("=================");
		
		one.call("乔布斯");
		one.sendMessage();
	}

}

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

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

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

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

package 面向对象;

public class Demo06 {
	
	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(null);//错误写法
		System.out.println(name);
	}
}

面向对象三大特征之封装性

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

封装性在Java当中的体现：
1.方法就是一种封装
2.关键字private也是一种封装

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

package 面向对象;

public class Demo07fengzhuang {

	public static void main(String[] args) {
		int[] array = {5,3,25,35,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和后面继承多态，关注我，我们还有后续。。。