黑马程序员__JAVA基础__面向对象(一)

-------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

1.面向对象的概念

理解面向对象：

1.面向对象是相对面向过程而言

2.面向对象和面向过程都是一种思想

3.面向过程强调的是功能行为

4.面向对象是将功能封装进对象，强调具备了功能的对象

5.面向对象是基于面向过程的

面向对象的特点：

1.是一种符合人们思考习惯的思想

2.可以将复杂的事情简单化

3.将程序员从执行都转换成了指挥者(此条最能体现面向对象)

完成需求时要先去打具有所需的功能的对象来用，如果该对象不存在，那么创建一个具有所需功能的对象，这样能简化开发并提高复用。

面向对象开发，设计，特征：

开发的过程就是不断的创建对象，使用对象，指挥对象做事情。

设计的过程就是在管理和维护对象之间的关系

面向对象的特征：封闭(encapsulation)，继承(inheritance)，多态(polymorphism)

2.类与对象的关系

使用计算机语言就是不断的在描述现实生活中的事物

Java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。

对象即是该类事物的实实在在的个体

如图：



可以理解为：

类就是图纸

汽车就是堆内存中的对象

类的定义

1.生活中描述事物无非就是描述事物的属性和行为

如：人有身高，体重等属性，有说话，打球等行为

2.java中用类class来描述事物也是如此

属性：对应类中的成员变量

行为：对应类中的成员函数

3.定义类其实在定义类中的成员(成员变量和成员函数)。

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

1.作用范围：成员变量作用于整个类中，整个类都可以被访问。而局部变量作用于函数或者语句中。

2.在内存中的位置：成员变量随着对象的建立而建立，存在于对象所在的堆内存中，因为对象的存在，才在内存中存在。而局部变量存在栈内存中，作用的范围结束，变量空间就会自己释放。

3.初始化方式：成员变量都默认的初始化值。而局部变量没有默认的初始化值。

面向对象示例：

Class Car//对Car这类事物进行描述
{
　　//属性描述
　　String color = "red";
　　int num = 4;
　　viod show()//运行行为
　　{
　　    System.out.println("color="+color+"..num=" +num);
　　}
}
class CarDemo
{
　　public static void main(String[] args)
　　{
Car c = nwe Car();//建立对象，c是类类型变量，指向对象
c.color = "blue";//对对象的属性进行修改
C.show();//使用对象的功能
//打印结果：color=blue..num=4
　　}
}

对象内存结构：



匿名对象

匿名对象是对象的简化方式

匿名对象两种使用情况

1.当对对象方法仅进行一次调用时(这样写比较简化)

2.匿名对象可以作为实际参数作为传递

public static void show(Car c)
{
　　c.num = 3;
　　c.color = "black";
　　C.run();
}
//调用：show(new Car());

3.封装(Encapsulation)

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

好处：

1.将变化隔离

2.便于使用

3.提高安全性

4.提高重用性

封装原则：

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

2.把属性都隐藏，提供公共方法对其访问。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作。提高代码健壮性。

4.private(私有)关键字

1.是一个权限修饰符。

2.用于修饰成员(成员变量和成员函数)。

3.被私有化的成员只在本类中有效。

示例代码：

class Person
{
　　//将age私有化以后，类以外即使建立了对象也不能直接访问
　　private int age;
　　//Person类中提供对应访问age的方式
　　public void setAge(int a)//设置
　　{
　　	if(a>0 && a<130)//在访问方式中加入逻辑判断语句
　　	{
age = a;
speak();
}
else
System.out.println("feifa age");
}
public int getAge()//获取
{
return age;
}
private void speak()//调用方法
{
System.out.println("age="+age);
}
}
　　
class PersonDemo
{
public static void  main(String[] args)
{
Person p = new Person();
p.setAge(40);
　　}
}

特别注意：私有仅仅是封装的一种表现形式。

构造函数

特点：

1.函数名与类名相同

2.不用定义返回值类型

3.不可以写return语句

作用：给对象进行初始化。

注意：

1.默认构造函数的特点：

对象一建立就会调用与之对应的构造函数

当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。

当在类中自定义了构造函数后，默认的构造函数就没有了。

2.多个构造函数是以重载的方式存在的。

构造代码块

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

与构造函数的区别：

1.构造代码块是给所有对象进行统一初始化，

2.构造函数是给对应的对象初始化。

3.构造代码快中定义的是不同对象共性的初始化内容。

5.this关键字

用于区分局部变量和成员变量同名情情况

特点：this代表其所在函数所属对象的引用(代表本类对象的引用)

什么时候使用this关键字呢？

当在函数内需要用到调用该函数的对象时，就用this，如：

class Person
{
　　private String name;
　　private int age;
　　/*
　　需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。
　　*/
　　public boolean compare(Person p)
　　{
　　	return this.age==p.age;//谁调用这个方法，this就代表谁
　　}
}　　　
class PersonDemo
{
　　public static void main(String[] args)
　　{
　　	Person p1 = new Person(20);
　　	Person p2 = new Person(25);
　　	boolean b = p1.compare(p2);//p1调用这个方法
　　	System.out.println(b);//输出结果为false
　　}
}

6.static(静态)关键字

用于修饰成员(成员变量和成员函数)

被修饰后的成员具备以下特点：

1.随意类的加载而加载

2.优先于对象存在

3.被所有对象所共享

4.可以直接被类名调用

使用注意：

1.静态方法只能访问静态成员(非静态方法既可以访问静态也可以访问非静态)

2.静态方法中不可以写this,super关键字(因为静态优先于对象存在。所以静态方法中不可以出现this)

3.主函数是静态的

静态的好处与弊端

好处：

1.对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。

2.可以直接被类名调用。

弊端：

1.生命周期过长。

2.访问出现局限性。(静态方法只能访问静态成员)

静态什么时候用？

1.什么时候定义静态变量(类变量)呢？

当对象中出现共享数据时，该数据要被静态所修饰。(售票的例子，票的数量)

对象中的特有数据要定义成非静态存在于堆内存中。

2.什么时候定义静态函数呢？

当功能内部没有访问到肺静态数据(对象的特有数据)，那么该功能可以定义成静态的。

静态代码示例：

class Person
{
　　String name;//成员变量，实例变量。
　　static String country = "CN";//静态的成员变量(类变量)，共享数据
　　public void show()
　　{
　　	System.out.println(name + "::::"+country);
　　}
}
　　
class  StaticDemo
{
　　public static void main(String[] args)
　　{
　　	Person p = new Person();
　　	p.name = "zhangsan";
　　	p.show();　　
　　	System.out.println(Person.country);//直接被类名调用
　　}
}

上述代码中有实例变量和类变量，他们的区别：

1.存放位置：

类变量随着类的加载而存在于方法区中。

实例变量随着对象的建立而存在于堆内存中。

2.生命周期：

类变量生命周期最长，随着类的消失而消失。

实例变量生命周期随着对象的消失而消失。

静态代码块

static

{

静态代码块中的执行语句。

}

特点：随着类的加载而执行，只执行一次,并优先于主函数，用于给类进行初始化的。

静态代码块，构造代码块，构造函数不同的作用：

static//静态代码块，给类初始化

{

}

//构造代码块，给对象初始化

{

}

Demo()//构造函数，给对应对象初始化

{

}

代码解析：

class Father
{
　　static//静态代码块，给类初始化
　　{
　　    System.out.println(“A”);
　　}
　　
　　//构造代码块，给对象初始化
　　{
　    　System.out.println(“B”);
　　}
　　
　　Father()//构造函数，给对应对象初始化
　　{
　    　System.out.println(“C”);
　　}
}
　　
class Child extends Father
{
　　static//静态代码块，给类初始化
　　{
　　    System.out.println(“D”);
　　}
　　
　　//构造代码块，给对象初始化
　　{
　　    System.out.println(“E”);
　　}
　　
　　Child()//构造函数，给对应对象初始化
　　{
　　    System.out.println(“F”);
　　}
}
　　
class Demo
{
　　public static void main(String[] args)
　　{
　　    Child c = new Child();
　　}
}
/*
打印结果：ADBCEF
原因：先给两个类初始化，再给对象初始化，最后给c这个对象初始化。(父类执行在前)
*/

个人总结

本节要理解java面前对象是什么，明白对象的建立与对象在内存中的存储方式和状态，以及掌握所学关键字，掌握封装的好处及合理运用封装，分清静态代码块，构造代码块，构造函数执行的先后顺序。概念性的东西比较多，应当结合代码多加理解。