面向过程与面向对象

1. 比较

   • 两者都是一种思想，面向对象是相对于面向过程而言的。
   • 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
   • 面向对象：将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
   • 举例：

2. 面向对象的三大特征：

   • 封装
   • 继承
   • 多态

3. 理解万事万物皆对象

   • 在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的结构。
   • 设计到Java语言与前端HTML、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

类和对象的理解

概念

1. 类：是对一类事物的描述，是抽象的，概念上的定义。
2. 对象：是实际存在的该类事物的每个个体，因此也称为实例（instance）
3. 类是抽象的，对象是类的实例。
4. 面向对象程序设计的重点是类的设计
5. 类的设计，其实就是类的成员的设计

成员的设计

• 属性 = 成员变量 = Field = 字段
• 方法 = 成员方法 = 函数 = method
• 代码块
• 构造器
• 内部类

类和对象的实现

步骤：
1. 创建类，设计类的成员
2. 类的实例化
3. 调用对象的结构

• 属性调用格式：实例对象.属性
• 方法调用格式：实例对象.方法()
• 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static）

package com.eachwang.www.java;

/*
 * 类和对象的实现
 */
public class PersonTest {
	public static void main(String[] args) {
		// 2. 创建实例
		Person p = new Person();
		// 3.调用属性，格式：实例对象.属性
		System.out.println(p.age);
		p.name = "Tom";

		// 3.调用方法，格式：实例对象.方法()
		p.eat();
		p.sleep();
		p.talk("简体中文");
	}
}

/*
 * 1.创建一个类，设计它的属性和方法
 */
class Person {
	// 属性
	String name;
	int age = 1;
	boolean isMr;

	// 方法
	// 吃饭方法
	public void eat() {
		System.out.println("人可以吃");
	}

	// 睡觉方法
	public void sleep() {
		System.out.println("人可以睡觉");
	}

	// 交流方法
	public void talk(String lanagule) {
		System.out.println("人可以说话，使用语言是：" + lanagule);
	}
}

内存解析：

类中属性的使用

成员变量（属性）和局部变量：

• 相同点：
  1. 都是变量，定义的格式都是一样的：数据类型 变零名= 值;
  2. 都要先声明，后使用。
  3. 都有自己的作用域：属性类作用域{}内，局部变量在方法内
• 不同点：
  1. 在类中声明的位置不同
     成员变量：声明在类{}内
     局部变量：声明在方法内
  2. 关于权限修饰符的不同：
     成员变量：可以在声明变量时，指明其权限。
     常见的权限修饰符：private、public、缺省、protected
     局部变量：不可以使用权限修饰符。
  3. 默认初始化的不同：
     成员变量：有默认初始化值：
     * 整型：（byte、short、int、long）：0
     * 浮点型：（float、double）：0.0
     * 字符型：（char）：0或'\u0000'
     * 布尔型：（boolean）：false
     * 引用数据类型：null
     局部变量：没有默认初始化只，使用前必须赋值。
  4. 在内存加载的位置不同：
     成员变量：加载到堆空间中（非static）
     局部变量：加载到栈空间中

public class UserTest {

}

class User {
	// 属性
	String name;
	int age;
	boolean isMale;

	public void talk() {

	}

	public void eat() {
		// 局部变量
		String food = "煎饼果子";
		System.out.println("山东人吃：" + food);
	}
}

类中方法的使用

• 格式：

  	权限修饰符 返回值类型 方法名(形参列表){
  			方法体
  	}
  

• 举例：
• 说明：
  1. 权限修饰符：Java规定了四种权限修饰符
  • public
  • protected
  • 缺省
  • private
  2. 返回值类型：
  • 有返回值：声明方法的时候必须指定返回值的类型。同时方法中必须使用retrun关键字返回指定类型的变零或常量：“return 数据”
  • 无返回值：声明方法的时候制定类型为void，在方法中return可有可无。
  • 我们定义方法该不该有返回值：
    • 看要求。
    • 凭经验。
  3. 方法名：属于标识符，要符合标识符命名规则。
  4. 形参列表：方法中可以声明0个或多个。

return关键字的使用

1. 使用范围：方法体内
2. 作用：
   • 结束方法
   • 针对有返回值的类型的方法使用return进行返回数据。

实例

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：
1) 生成随机数：Math.random()，返回值类型double;  
2) 四舍五入取整：Math.round(double d)，返回值类型long。

public class StudentTest {
	public static void main(String[] args) {
		Stu[] stus = new Stu[20];
		for (int i = 0; i < stus.length; i++) {
			Stu stu = new Stu();
			stu.number = i + 1;
			// 年级
			stu.state = (int) (Math.random() * 5 + 1);
			// 成绩
			stu.score = (int) (Math.random() * 100);
			stus[i] = stu;
		}

		// 打印所有学生信息
		for (int i = 0; i < stus.length; i++) {
			System.out.println(stus[i].toString());
		}
		System.out.println("--------------");

		// 打印年级为3的学生信息
		for (int i = 0; i < stus.length; i++) {
			if (stus[i].state == 3) {
				System.out.println(stus[i].toString());
			}
		}

		System.out.println("--------------");

		// 使用冒泡排序按照学生成绩排序
		for (int i = 0; i < stus.length - 1; i++) {
			for (int j = 0; j < stus.length - 1 - i; j++) {
				if (stus[j].score > stus[j + 1].score) {
					Stu temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
		// 输出信息
		for (int i = 0; i < stus.length; i++) {
			System.out.println(stus[i].toString());
		}
	}
}

class Stu {
	int number;
	int state;
	int score;

	public String toString() {
		return "学号：" + number + "，年级：" + state + "，成绩：" + score;
	}
}

匿名对象

1. 理解：创建的对象，没有显式的赋值给一个变量名，即是匿名对象；
2. 特征：匿名对象只能调用一次。
3. 使用：

public class InstanceTest {
	public static void main(String[] args) {
		// 使用匿名对象调用，调用这两个的对象不是同一个对象
		// 匿名对象只能调用一次
		new Phone().sendEmaill();
		new Phone().playGames();

		// 我们一般使用如下:创建一个工厂类
		//看似匿名的phone是匿名的，但实际上赋值给了showPhone方法中的形参
		new PhoneMall().showPhone(new Phone());
	}
}

class PhoneMall {
	public void showPhone(Phone phone) {
		phone.sendEmaill();
		phone.playGames();
	}
}

class Phone {
	public void sendEmaill() {
		System.out.println("发送邮件");
	}

	public void playGames() {
		System.out.println("玩游戏");
	}
}

Day08问题

1. 面向对象编程内容的三条主线是什么？
   • 类及类的成员：属性 方法 构造器 代码块 内部类
   • 三大特性：封装 继承 多态
   • 关键字：static this super interface final package import等
2. 谈谈你对面向对象中类和对象的理解，并指出两者的关系。
   • 类是抽象的，概念上的内容，对象是类的实例化，是实实在在存在的一个个体。
3. 面向对象思想体现1：类和对象的创建和执行操作步骤有哪些。
   • 创建类，设计类的属性和方法。
   • 创建类的实例
   • 通过类的实例调用类的方法。
4. 指出如下代码在执行时的内存分配情况。
5. 类的方法是否可以定义变量？是否可以调用属性？是否可以定义方法？是否可以调用方法？
   • 是
   • 是
   • 否
   • 是

其他题目

int[] arr = new int[]{1,2,3,4};
System.out.println(arr);

char[] arr1 = new char[]{'a','b','c'};
System.out.println(arr1);

输出结果：

原因：

本文由 Gorrywang 创作，严禁转载与复制！
最后编辑时间为: Aug 4,2020