零基础学java的第四天

Day 04 面向对象（一）

1.面向对象与面向过程
2，java的基本元素：类与对象
3.对象的创建与使用
4.类的成员一：类 属性
5.类的成员二：方法
6.oop特征：封装
7.类的成员三：构造器
8.关键字：this
9.关键字：package import

面向过程与面向对象

面向过程POP procedure oriented programming

• 以函数作为最小单位，考虑怎么做

面向对象OOP object oriented programming

• 以类/对象作为最小单位，考虑谁来做
  • 多态 polymorphism
  • 继承 inheritance
  • 封装 encapaulation
    （PIE）

面向过程：（人把大象放进冰箱）
1.打开冰箱
2.把大象放到冰箱里
3.把冰箱门关上

面向对象
人{
	打开（冰箱）{
		冰箱.开门（）；
	}
	操作（大象）{
	大象.进去（冰箱）；
	}
	关闭（冰箱）{
	冰箱.关门（）；
	}
}
冰箱{
	开门（）{}
	关门（）{}
}
大象{
	进去（冰箱）{}
}

面向对象的思想概述

• 程序员从面向过程到执行者转化成面向对象的指挥者
• 面向对象的分析方法分析问题的思路：
  根据问题需要，选择问题针对的现实世界的实体

我要开车去学校     人   车    学校
人在黑板上画画     人    黑板
列车司机紧急刹车   列车司机   列车
你把门关上            人     门
售票员统计小票金额   人  小票

从实体中寻找解决问题的相关属性和功能，相关属性和功能就形成概念世界中的类

• 类class和对象object都是面向对象的核心
  • 类是对一类事物的描述，是抽象的定义
  • 对象是实际存在的该类的每个个体，因此也成为实例 （instance）
    “万事万物皆为对象”
• 面向对象的程序设计重点就是类的设计
• 类的设计，其实就是类的成员的设计
  • 属性：对应类中的成员变量
  • 行为：对应类中的成员方法 函数

1.旅行社 tourist agency
	1.1 订机票
	1.2 查收机票
	1.3 召集旅客
	1.4 分发机票
	1.5 收钱
2. 机场 airport
	2.1 出机票
	2.2 排座位
	2.3 收钱
	2.4 记账
	2.5 出发票
	2.6 接待旅客
	
	航班信息
3. 旅客 tourist
	3.1 花钱
	3.2 去旅游
	3.3 选位置
	3.4 坐车

类与对象的声明

类的语法格式
修饰符 class 类名{
属性声明；
方法声明；
}

• 修饰符public让类能够随意访问，类的正文需要用{}括起来

public class Person{
	private int age;//声明了私有变量age
	public void showAge(int i){
		age = i;
	}//声明方法showAge()
}

如何创建java自定义类
步骤：

1. 定义类（考虑修饰符 类名）
2. 编写类的属性（考虑修饰符 属性类型 属性名 初始化值）
3. 编写类的方法（考虑修饰符 返回值类型 方法名 形式参数）

1.定义Car类
	猫能吃猫粮 猫有4条腿 猫有尾巴 猫会叫

java 类及类的成员
	如何使用java类？
java类的实例化，即创建该类的对象

对象的创建和使用

创建对象语法：类名 对象名 = new 类名（）；

使用“对象名.对象成员”的方式能够访问的对象成员（属性和方法）

类的访问机制

• 在一个类中的访问机制
  类中的方法可以直接访问到类中的成员变量
  （例外：static方法访问static成员，编译不通过）
• 在不同类中的访问机制
  先创建要访问的对象，通过对象访问类中定义的成员

对象的产生

Person p1 = new Person();

//其中类的定义如下：
class Person{
	int age;
	void shout(){
		System.out.println("hi");
	}
}

class PersonTest{
	public static void main(String args[]){
	Person p1 = new Person();
	p1.age = 30;
	p1.shout();
	}
}

对象的生命周期

{
	Person p1 = new Person();
	...
}

{1-4}行中Person对象被引用
在第5行时,p1就被销毁 p1与Person对象

{
	Person p1 = new Person();
	...
	p1 = null;
}
{1-3}行中Person对象被引用
在第4行时,p1被置空 Person对象成为垃圾

{
	Person p1 = new Person();
	Person p2 = p1;
	...
	p1 = null;
}
{1-4}行 Person对象被引用
在第5行时,p1被置空 p2? Person对象?
p2 = Person对象
p1 = null

p2 = p1
且 
p2 = person对象
{
	String p1 = "1";
	String p2 = p1;
	...
	p1 = null;
}

对象的创建使用：内存解析

• 堆(heap) 放对象实例
• 通常栈说的是虚拟机栈,用于存储局部变量等
• 方法区:放被虚拟机加载的类信息,常量,静态变量,即时编译器编译后的代码

class Car{
	String color = "red";
	int num = 4;
	void show(){
		sout("Color="+color);
	}
}
class CarTest{
	main{
		Car c1 = new Car();
		Car c2 = new Car();
		c1.color = "blue";
		c1.show();
		c2.show();		
	}
}

匿名对象

• 不定义对象的引用，直接调用对象的方法，这样的对象就叫匿名对象

new Person().shout();

• 使用情况
  • 如果对一个对象只需要进行一次发的方法调用，那么就可以使用匿名对象
  • 我们经常会把匿名对象作为实参传递给一个方法使用

类的成员之一：属性

修饰符 数据类型 属性名 = 初始化值

• 说明1:修饰符

  • 常用的权限修饰符为:不填,private protected public
  • 其他修饰符: static final

• 说明2:数据类型

  • 任何的基本数据类型或任何引用类型

• 说明3:属性名

  • 属于标识符,符合命名规则和规范即可

变量的分类: 成员变量与局部变量

• 在方法体外,类体内声明的变量是成员变量
• 在方法体内声明的变量是局部变量

成员变量
	1.实例变量(不以static修饰)
	2.类变量(以static修饰)

局部变量
	1.方法局部变量(方法内定义)
	2.代码块局部变量(代码块内定义)

异: 局部变量除形式参数外,都需要显式初始化
同: 都有生命周期

成员变量(属性)与局部变量的区别?

	成员变量	局部变量
声明的位置	类中,方法外	方法体内,代码块内,构造器内
修饰符	private public static final	只能用final修饰
初始化值	有默认初始化值	没有,必须显式初始化才能使用
内存加载位置	堆空间或静态域	栈空间

对象属性的默认初始化赋值:

成员变量类型	初始值
byte	0
short	0
int	0
long	0
float	0.0F
double	0.0
char	0 “\u0000”(表现为空)
boolean	false
引用类型	null

类的成员之二: 方法

method 函数/过程/方法

修饰符 返回值类型 方法名 (参数类型 形参1,参数类型 形参 2,…){

​ 方法体程序代码

​ return 返回值;

}

• 修饰符: 不填,public,private,protected

• 返回值类型:

  • 没有返回值: void
  • 有返回值:声明返回值的类型.与方法体中的"return 返回值"配合使用

• 方法名: 属于标识符,命名时候最好是"见名知意"

• 返回值:方法在执行完毕后返还给调用它的程序的参数

注意

• 方法被调用一次,就执行一次
• 没有具体返回值的情况,返回值类型用关键字void表示,那么方法中可以不用return语句.如果使用,仅用于结束方法
• 定义方法时,方法的结果应该返回给调用者,交给调用者处理
• 不能在方法中定义方法

利用面向对象的编程方法,设计类Circle计算圆的面积
1.Driver
2.Circle

类的方法重载

• 在同一个类里面,允许有一个或多个同名的方法,只要参数个数或者类型不一样就可以

• 与返回值的类型无关,只看参数列表,且参数列表必须不同

• int add(int x,int y){return x+y;}
  int add(int x1,int y1){return x1+y1;}     F
  int add(int x,int y,int z){return x+y;}   T
  double add(int x,int y){return x+y;}      F
  

与void show（int a，char b，double c）构成重载的有∶ 
a) void show(int x,char y,double z) no
b) int show(int a,double c,char b) yes
c) void show(int a,double c,char b) yes
d) boolean show(int c,char b) yes
e) void show(double c) yes
f) double show(int x,char y,double z) no
g)void shows(){double c} no