黑马程序员_面向对象（上）

                                                       ---------------------- android培训、java培训、期待与您交流！ ----------------------  

一，面向对象

1，概述：

面向对象是相对面向过程而言，

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

面向过程：

强调的是功能行为；

面向对象：

将功能封装进对象，强调具备了功能的对象。

面向对象是基于面向过程的。

2，特点：

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

可以将复杂的事情简单化，

将程序员从执行者转换成了指挥者。

完成需求时：

先要去找具有所需的功能的对象来用。

如果该对象不存在，那么创建一个具有所需功能的对象。

这样简化开发并提高复用。

三个特征：封装，继承，多态

开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。没有对象，就创建一个对象。

一句话:找对象，建立对象，使用对象。维护对象的关系。

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

二：类和对象的关系   

使用计算机语言就是不断的在描述现实生活中的事物。java中描述事物通过类的形式体现，类是具体事物的抽

像，概念上的定义。对象即是该类事物实实在在存在的个体。

可以用一个图来表示：

一句话：

类就是：对现实生活中事物的描述。

对象：就是这类事物，实实在在存在个体。

1，类

类就是同一类事物的统称，如果将现实世界中的一个事物抽象成对象的话，类就是这类对象的统称

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

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

Java中用类class来描述事物也是如此

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

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

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

类的定义可以用代码来表示为：

class className //calssName是要定义的类的名称

{

/*

类中可以定义多个成员变量和成员方法，main()方法是一种特殊的成员方法，作为程序

执行的入口方法，用于执行程序。

*/

成员变量

···········

成员方法

}

成员变量：

成员变量是在类体中定义的变量，即全局变量，成员变量用于定义对象的状态。 

例如Student类有name、age、sex等成员变量分别表示姓名、年龄、性别等状态。

class Student

{

public String name; //姓名

public int age; //年龄

public String sex;//性别

}

注意：成员变量必须直接定义在类体中，如果定义在其他方法或代码块中，就会成为局部变量，而不是成员变

量。成员变量是给对象使用的，每个对象被创建以后，都会有属于自己的属性，通过修改这些属性，从而改变

对象的某个状态。

成员方法：

成员方法是对象行为的描述。每个方法都是由复合语句描述相应的行为。定义成员方法的语法格式如下：

[修饰符] 返回值类型 方法名([形参表]){
      ...//方法体
      return 返回值;
}

修饰符：可以是public、private、protected以及static、final等。修饰符是可选的语法部分。

返回值类型：如果方法需要返回值，必须在这里声明方法的返回值类型，可以使基本数据类型（int、short、double、boolean等），也可以是对象类型（例如数组、字符串等）

方法名：这是必须的方法定义部分，程序将通过该名称调用这个方法。

形参表：这是可选部分，说明方法被调用时，应该向它传递的数据。

形参表由1到多个形式参数构成，当方法有多个形式参数时，参数之间使用“，”逗号分割；如果方法没有参数，

可以省略“形参表”部分。

比如：

public void studentInformation(String name,int age,String sex)

{

  //方法体

}

局部变量：

如果在成员方法内定义一个变量，那么这个变量被称为局部变量，局部变量只在定义它的方法内有效。

比如：

public class Test

{

public Test()//成员方法

{

int x =0;//局部变量

System.out.println(x);

}

}

注意：局部变量是在方法被执行时创建，在方法执行结束时被销毁，局部变量在使用时必须进行赋值操作或被

初始化，否则会出现编译错误。

局部变量的有效范围：

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止

在相互不嵌套的作用域中可以同时声明两个名称、类型相同的局部变量，列如：

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

成员变量：

成员变量定义在类中，在整个类中都可以被访问。

成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

成员变量有默认初始化值。

局部变量：

局部变量只定义在局部范围内，如：函数内，语句内等。

局部变量存在于栈内存中。

作用的范围结束，变量空间会自动释放。

局部变量没有默认初始化值。

2，对象

在计算机的世界中，面向对象程序设计的思想要以对象来思考问题，首先要将现实世界的实体抽象为对象，然

后考虑这个对象具备的属性和行为

创建类的实例对象需要使用new语句，声明并创建对象的语法格式如下。

类名 对象名=new 类构造方法();

类名：这是要创建实例对象的类的名称。

对象名：它可以看作是一个变量，这个变量名就是创建的实例对象的名称。

构造方法：是类创建对象时必须执行的方法，用于构造一个新的对象并初始化对象属性。

比如：

String name = new String("一个新的字符串对象");

注意：每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的生命周期，当一

个对象的生命周期结束时，对象变成了垃圾，由Java虚拟机自带的垃圾回收机制处理。不能再被使用。

访问对象的属性和行为：

对象名.属性

对象名.成员方法名()

在对象名后面使用“.”操作符连接对象的属性或方法。

对象的引用：

在Java语言中尽管一切都可以看作对象，但真正操作标识符实质上是一个引用

类名 对象引用名称

比如一个Book类的引用可以使用如下代码：

Book book; //通常一个引用不一定需要有一个对象相关联。

引用与对象相关联的语法：

Book book= new Book();

Book book= new Book();

Book：类名。

book：对象。

new：创建对象操作符。

注意：引用只是存放一个对象的内存的地址，并非存放一个对象，严格说引用和对象是不同的，但是可以将这

种区别忽略，如可以简单的说book是Book类的一个对象，而事实上应该是book是包含Book对象的一个引用。

创建对象使用对象比如：

class Car//对Car这类事物进行描述

{

  String color = "red";

  int num = 4;

  void show()

  {

  System.out.println("color="+color+"..num="+num);

  }

}

class CarDemo

{

  public static void main(String[] args)

  {

  Car c = new Car();//建立对象

  c.color = "black";//对对象的属性进行修改

  c.show();//使用对象的功能。

  }

}

对象的销毁：

大多数面向对象的编程语言，要求显示地销毁某个对象，这点就没有Java做的好，Java语言提供了垃圾回收机

制，对于不再使用的对象会自动销毁，也可以在程序中显示的为某个对象赋值null值，使对象不再被使用。

3，匿名对象

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

匿名对象两种使用情况

匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。

如果对一个对象进行多个成员调用，必须给这个对象起个名字。

匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。

4，private(私有)关键字

是一个权限修饰符。

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

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

常用之一：

将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。

注意：私有仅仅是封装的一种表现形式。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等

语句。

对访问的数据进行操作。提高代码健壮性。

5，构造函数

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

特点：

1，函数名与类名相同

2，不用定义返回值类型

3，不可以写return语句

作用：

给对象进行初始化

注意：

默认构造函数的特点

多个构造函数是以重载的形式存在的

构造函数的小细节：

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

，默认的构造函数就没有了。这个默认的构造函数的权限和所属类一致。如果类被public修饰，那么默认的构造函数

也带public修饰符。如果类没有被public修饰，那么默认的构造函数，也没有public修饰。

默认构造构造函数的权限是随着的类的变化而变化的。

构造函数和一般函数在写法上有不同，在运行上也有不同。

构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行，给对象添加对象具备的功能。

一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。

什么时候定义构造函数呢？

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

6，构造代码块

作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。

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

7，this关键字

this代表它所在函数所属对象的引用。

简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。

但凡本类功能内部使用了本类对象，都用this表示。

this语句 :用于构造函数之间进行互相调用。

this语句只能定义在构造函数的第一行。因为初始化要先执行。

比如：

private  void setName(String name)

{

this.name = name;//将参数值赋予类中的成员变量

}

this也可以作为方法的返回值，比如：

public Book getBook()

{

return this;  //返回Book类引用

}

在getBook()方法中，方法的返回值为Book类型，所以方法体中使用return this这种形式将Book类型的对象进行返回。

8，static(静态)关键字

静态：static。

用法：是一个修饰符，用于修饰成员(成员变量，成员函数).

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，

还可以直接被类名调用。类名.静态成员。

static特点：

1，随着类的加载而加载。

也就说：静态会随着类的消失而消失。说明它的生命周期最长。

2，优先于对象存在

明确一点：静态是先存在。对象是后存在的。

3，被所有对象所共享

4，可以直接被类名所调用。

实例变量和类变量的区别：

1，存放位置。

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

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

2，生命周期：

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

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

静态使用注意事项：

1，静态方法只能访问静态成员。

非静态方法既可以访问静态也可以访问非静态。

2，静态方法中不可以定义this，super关键字。

因为静态优先于对象存在。所以静态方法中不可以出现this。

3，主函数是静态的。

静态有利有弊
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊端：生命周期过长。
 访问出现局限性。(静态虽好，只能访问静态。)

注意：在Java中规定不能将方法体内的局部变量声明为static的。

如果在执行类时，希望先执行类的初始化动作，可以使用static定义一个静态区域，例如：

public class Example 

{

static   //静态代码块

{

//some

}

}

当这段代码被执行时，首先执行static块中的程序，并且只会执行一次，并优先于主函数。

用于给类进行初始化的

什么时候使用静态？

要从两方面下手：

因为静态修饰的内容有成员变量和函数。

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

当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。

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

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

三，设计模式

设计模式：解决某一类问题最行之有效的方法。

java中23种设计模式：

单例设计模式：解决一个类在内存只存在一个对象。

想要保证对象唯一。
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三步怎么用代码体现呢？
1，将构造函数私有化。
2，在类中创建一个本类对象。
3，提供一个方法可以获取到该对象。

对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

比如：

class Single
{
private static Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}

这个是先初始化对象。称为：饿汉式。
Single类一进内存，就已经创建好了对象。

class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s = new Single();
}
}
return s;
}
}

对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。

Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

记录原则：定义单例，建议使用饿汉式。

                                  ---------------------- android培训、java培训、期待与您交流！ ----------------------