黑马程序员－－－－面象对象及封装

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

第一讲 面向对象的概述

一.概述

面象对象是一种符合人类思维习惯的编程思想.。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

面向过程: 步骤和过程

面向对象: 对象

面向对象基于面向过程

举例:

洗衣服:

面向过程: 脱下衣服 --- 放进盆里 --- 加点水 ---- 加点洗衣粉 --- 泡一会儿 --- 搓一搓 --- 涮一下 --- 捞出来晾干

面向对象: 脱下衣服 --- 放进全自动洗衣机里面 --- 捞出来晾干

吃饭:

面向过程: 买菜 --- 摘菜 --- 洗菜 --- 切菜 ---- 炒菜 --- 盛出来 --- 吃

面向对象: 上餐馆 --- 服务员点餐 ---- 厨师做饭 --- 服务员盛出来 --- 吃

我们在现实生活中怎么描述一个事物的呢?

描述学生:

姓名 , 年龄, 性别 .....

学习 , 吃饭, 睡觉 ....

属性: 事物的描述信息

行为: 该事物可以做什么事情

而我们java语言的最小单位是类,那么我们就应该将事物和类对应起来

事物 类

属性 成员变量

行为 成员方法

成员变量: 和之前定义变量的方式一样,只不过位置不同,在类中方法外

成员方法: 和之前定义方法一样,只不过去掉static(以后在讲解)

类: 就是一组相关属性和行为的集合,是一个抽象的东西

对象: 就是该类的一个具体体现

举例: 学生: 类

班长: 对象

二，下面用代码说下成员变量跟成员方法

<span style="color:#000099;">class Student {

// 成员变量
String name = "张三";			// 姓名
int    age  = 24 ;				// 年龄
String sex  = "女";				// 性别

// 成员方法
// 学习
public void study(){
System.out.println("学生在学习....");
}

// 吃饭
public void eat(){
System.out.println("学习饿了该吃饭了....");
}

// 睡觉
public void sleep(){
System.out.println("学习累了该睡觉了....");
}
}</span>

第二讲 面向对象类的使用及成员方法的调用

一，类的使用

类是一个抽象的东西,我们不能直接使用,我们需要该类的一个具体体现(对象)

怎么得到这个对象: 格式: 类名 对象名 = new 类名();

二，获取成员变量

格式: 对象名.变量名

三，成员方法的调用

格式: 对象名.方法名(...)

四，下面用代码加注释实现

<span style="color:#000066;">// 学生类
class Student {

// 成员变量
/*
String name = "张三";		// 姓名
int	   age  = 24 ;			// 年龄
String sex  = "女" ;		// 性别
*/

String name ;		// 姓名		// null
int	   age  ;		// 年龄		// 0
String sex  ;		// 性别		// null

// 成员方法
// 学习
public void study(){
System.out.println("学生在学习....");
}

// 吃饭
public void eat(){
System.out.println("学习饿了该吃饭了");
}

// 睡觉
public void sleep(){
System.out.println("学习累了该睡觉了");
}
}

// 测试类
class StudentDemo {

public static void main(String[] args){

// 创建学生对象
// 类名 对象名 = new 类名();
Student s = new Student();

// 给对象赋值
s.name = "张三";
s.age = 24 ;
s.sex = "男";

// 如何获取成员变量
// 格式: 对象名.变量名
/*
String name = s.name ;
System.out.println(name);
*/

System.out.println(s.name + "----" + s.age + "----" + s.sex);

// 调用成员方法
// 格式: 对象名.方法名(...)
s.study();
s.eat();
s.sleep();

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

// 类名 对象名 = new 类名();
Student s2 = new Student();

// 给成员变量赋值
s2.name = "李四";
s2.age = 21 ;
s2.sex = "女";

System.out.println(s2.name + "----" + s2.age + "----" + s2.sex);

// 格式: 对象名.方法名(...)
s2.study();
s2.eat();
s2.sleep();</span>

第三讲 成员变量与局部变量的区别及this关键字

一，在类中的位置不同

局部变量: 在方法定义中或者方法声明上

成员变量: 在类中方法外

<span style="color:#000066;">class student{
int a = 10;//这是成员变量
}
public class studentDemo {
public static void main(String[] args) {
int a = 10;//这是局部变量
}
}</span>

二，在内存中的位置

局部变量: 在栈内存

成员变量: 在堆内存

三，生命周期不同

局部变量: 随着方法的调用而产生,随着方法的消失而消失

成员变量: 随着对象的创建而产生,随着对象的消失而消失

四，默认值不同

局部变量: 局部变量在使用的时候必须对其赋值

成员变量: 系统会为其分配一个默认值

注意；局部变量是可以和成员变量同名的，我们变量的访问遵循一个"就近原则"。为解决成员变量与局部变量的冲突，java给我们提供了一个关键字this,它可以明确的去访问同一个类的成员变量 this: 代表的是本类对象的一个引用

谁调用方法,这个方法中的this代表的就是谁

第四讲 参数传递

一，java语言的的参数传递问题:

基本数据类型的传递,形式参数的改变,对实际参数没有直接影响

引用数据类型的传递,形式参数的改变,对实际参数是有直接影响的

如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

<span style="color:#000066;">class Demo {
public int add(int a , int  b){
return a + b ;
}
}

class Student {
public void method(){
System.out.println("student...method方法被调用了");
}
}

class Demo2 {

// 如果以后看到方法上需要的是一个类类型的变量,那么这里其实需要的是该类的一个对象
public void function(Student s){		// Student s = new Student();
s.method();
}
}

// 测试类
class StudentDemo {

public static void main(String[] args){

// 创建Demo对象
Demo d = new Demo();

// 赋值调用
int result = d.add(10 , 30);
System.out.println(result);

// 创建Demo2的对象
Demo2 d2 = new Demo2();

// 创建Student对象
Student s = new Student();

//调用function方法
d2.function(s);
}

}</span>

第五讲 匿名对象

一，匿名对象:

就是没有名字的对象

作用:

调用方法,仅仅调用一次的时候

作为方法的参数传递

<span style="color:#000066;">class Student {

public void show(){
System.out.println("show方法被调用了");
}

}

class Demo {

public void method(Student s){
s.show();
}

}

// 测试类
class NoNameDemo {

public static void main(String[] args){

// 创建学生对象
Student s = new Student();

// 调用show方法
s.show();
s.show();

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

// 匿名对象
new Student().show();
new Student().show();		//输出结果是一样， 每new一次会重新创建一个对象,这两个对象是不同的，不相等的

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

// 创建Demo对象
Demo d = new Demo();

// 创建Student对象
Student s1 = new Student();

// 调用method方法
d.method(s1);

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

// 使用匿名对象调用method方法
d.method(new Student());

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

new Demo().method(new Student());

}

}</span>

第六讲 面向对象三大特征之一 封装

一，概述

我们使用成员变量对其赋值,出现了问题,我们需要对数据进行校验.

StudentDemo是一个测试类,测试类测试的时候需要包含所有的数据: 正确数据 ,错误数据,临界数据.

那么我们就不能将校验逻辑写在测试类

我们只能写在Student类中: 我们校验的时候需要编写一些逻辑语句,语句只能写在方法里面

我们只是定义了一个方法,如果我们不使用方法对其赋值,而是使用属性对其赋值,那么还没有达到一个安全的效果

于是乎,我们就需要其强制使用方法来对其年龄赋值,我们就需要这个age不能被外界访问

这时候java就给我们提供了一个关键字: private(私有的)

封装的思想:

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装好处

隐藏实现细节，提供公共的访问方式

提高了代码的复用性

提高安全性。

封装原则

将不需要对外提供的内容都隐藏起来。

把属性隐藏，提供公共方法对其访问。

二，private关键字

1 private的特点:

A: private是一个修饰符(私有的)

B: 可以用来修饰成员变量和成员方法

C: 被private修饰的成员只能在本类中访问

<span style="color:#000066;">class Private {

// 成员变量
// int num = 10 ;
private int num = 20 ;

public void show(){
System.out.println(num);
}

private void function(){
System.out.println("Private...function方法被调用了");
}

public void function2(){
function();
}

}

// 测试类
class PrivateDemo {

public static void main(String[] args){

// 创建Private对象
Private p = new Private();

// 输出num
// 错误的: 因为num被private修饰了
// System.out.println(p.num);

// 调用show方法
p.show();

// 调用function方法
// 错误的: 因为function被private修饰了
// p.function();

// 调用function2方法
p.function2();

}

}</span>

private最常见的应用:

A: 把成员变量通过private修饰

B: 提供对应的getXxx()和setXxx()方法

<span style="color:#000066;">class Student {

// 成员变量
private String name ;			// 姓名
private int		age ;			// 年龄
private String sex ;			// 性别

// 提供get和set方法
public String getName(){
return name ;
}

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

public int getAge(){
return age ;
}

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

public String getSex(){
return sex ;
}

public void setSex(String s){
sex = s ;
}

// 提供一个show方法显示所有的成员变量
public void show(){
System.out.println(name + "---" + age + "----" + sex);
}
}

// 测试类
class StudentDemo {

public static void main(String[] args){

// 创建学生对象
Student s = new Student();

// 给成员变量赋值

// 错误的: 因为name被private修饰
// s.name = "张三";
s.setName("刘亦菲");
s.setAge(28);
s.setSex("女");

// 使用show方法显示所有的成员变量
s.show();

// 使用get方法获取所有的成员变量
System.out.println(s.getName() + "---" + s.getAge() + "----" + s.getSex());
}

}</span>