黑马程序员——Java语言基础——03.面向对象（1）思想和一些概念

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

本节考点：

一、说说面向对象的思想
见正文
二、单例设计模式
单例设计模式分为饿汉式和懒汉式，主要考懒汉式，而且要用同步代码块

class SingleDemo
{
/*
单例模式：
1.将对象的构造函数私有，使外部不能创建对象
2.类内部创建对象
3.提供一个方法，供外部引用
*/
public static void main(String[] args)
{
Single s1 = Single.getInstence();
Single s2 = Single.getInstence();
s1.setNum(20);
System.out.println("num="+s2.getNum());
}
}
//饿汉式，要先吃饱。就是先创建了对象
class Single
{
private Single(){}
private static Single s = new Single();
public static Single getInstence()
{
return s;
}
private int num;
public void setNum(int num)
{
this.num = num;
}
public int getNum()
{
return num;
}
}
//懒汉式，能不做就不做，需要使用时才建立对象。
class Single
{
private Single(){}
private static Single s = null;
public static Single getInstence()
{
if(s == null)
s = new Single();
return s;
}
}
//解决懒汉式同时创建两个对象的隐患
class Single
{
private Single(){}
private static Single s = null;
public static Single getInstence()
{
if (s == null)
{
synchronized(Single.class);
{
if(s == null)
s = new Single();
}
}
return s;
}
}

1.1 面向对象思想

1-1-1 理解面向对象

面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。


面向过程 是一种以 事件 为中心的编程思想。

面向对象(Object Oriented,简称OO) 是一种以 事物 为中心的编程思想

    下面以公共汽车为例，分别讲述 面向过程 和 面向对象 在程序设计时的区别。

    面向过程 就是汽车启动是一个事件，汽车到站是另一个事件。在编程序的时候我们更关心的是某一个事件。而不是汽车本身。我们分别对启动和到站编写程序。类似的还有修理等等。

    编写程序就是：

public class 运营
{
void 汽车启动
{
}

void 汽车到站
{
}
} <span style="background-color: rgb(255, 255, 255);"> </span>

    面向对象 需要建立一个汽车的实体，由实体引发事件。我们更关心的是一个汽车实体而不是汽车的每个事件。

    编写程序就是：

public class 汽车
{
void 到站()
{
}

void 启动()
{
}
}

面向过程：

强调的是功能行为。代表语言：C语言。
例子：把大象装进冰箱
1、打开冰箱。

2、存储大象。

3、关上冰箱。"打开"、"存储"、"关上"都是功能行为，在代码中的直观体现就是函数或者方法，这就是一种面向过程的以功能行为为主体的思想体现。
面向对象：

将功能封装进对象，强调具备了功能的对象。代表语言：Java、C++、C#。
例子：把大象装进冰箱
1、冰箱打开。

2、冰箱存储。

3、冰箱关闭。
可以看到，所有的操作都是以"冰箱"为主体，而不是功能行为。
也就是说冰箱自己已经具备"打开"、"存储"、"关上"的行为功能，我们只需要让冰箱执行它具备的功能就可以了。
这就是一种面向对象的以执行功能的对象为主体的思想体现。

1-1-2 面向对象的特点

是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者。

完成需求时：

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

2、如果该对象不存在，那么创建一个具有所需功能的对象。
这样可以简化开发并提高复用。

1-1-3 面向对象开发，设计，特征

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

设计的过程：
其实就是在管理和维护对象之间的关系。
面向对象的特征：
封装(encapsulation)

继承(inheritance)

多态(polymorphism)

1-2 类与对象的关系

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

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

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

1-2-1 类与对象(图例)

类与对象的关系如图：

可以理解为：类就是图纸，汽车就是堆内存中的对象。

对于同一类事物可以抽取它们的共性的内容，定义在类中。如：生活中的汽车，每一台车都有轮胎数和颜色。

那么在通过java描述汽车这类事物时，就可以将这两个共性属性作为类中的属性进行定义。
通过该类建立的每一个汽车实体都具有该属性，并可以有对象特有的属性值。

1-2-2 类的定义

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

如：人有身高，体重等属性，有说话，打球等行为。
Java中用类class来描述事物也是如此。

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

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

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

1-2-3 成员变量和局部变量的区别？

成员变量：

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

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

③成员变量有默认初始化值。
局部变量：

①局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

②局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

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

1-2-4 创建对象，使用对象

示例：

Car.java
//对Car这类事物进行描述
class Car
{
//成员变量
String color = "red";
int num = 4;
//成员方法
void show()
{
//临时变量
int num = 10;
//输出临时变量的值
System. out.println("color = " +color +"...num = " +num);
}
}

class CarDemo
{
public static void main(String[] args)
{
//通过new关键字，建立对象
//c就是一个类类型的引用变量，指向了该类的对象
Car c = new Car();
//对对象的属性进行修改
c. color = "black" ;
//输出成员变量的默认值
System. out.println(c.num );
//通过对象.成员的形式来使用对象的功能
c.show();
}
}

1-2-5 匿名对象

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

匿名对象两种使用情况：①当对对象方法仅进行一次调用时；②匿名对象可以作为实际参数进行传递。

示例：

Car.java
class Car
{
String color = "red";
int num = 4;

public static void run()
{
System. out.println("function run is running!" );
}
}

class CarDemo{
public static void main(String[] args){
//对对象方法仅进行一次调用时，就可以使用匿名对象
new Car().run();
//匿名对象可以作为实际参数进行传递
show(new Car());
}

public static void show(Car c){
c. num = 3;
c. color = "black" ;
System. out.println("function show is running!" );
System. out.println(c.num + "..." + c. color);
}
}

1-3 构造函数

特点：

①函数名与类名相同。

②不用定义返回值类型。

③没有具体的返回值。
附：在构造函数前面加上返回值就只是一般函数了。

作用：

给对象进行初始化。

示例：

Person.java
class Person{
private String name ;
private int age ;

//定义一个Person类的构造函数
//构造函数，而且是空参数的
Person(){
System. out.println("person run" );
}

public void speak(){
System. out.println(name + ":" + age);
}
}

class ConsDemo{
public static void main(String[] args){
//构造函数：构建创造对象时调用的函数
//作用：可以给对象进行初始化
Person p = new Person();
p.speak();
}
}

注意：
1、一般函数和构造函数什么区别呢？
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要函数功能时才调用。

构造函数：对象创建时，会调用并且只调用一次。

一般函数：对象创建后，可以被调用多次。

2、创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

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

1-4 this关键字

this代表其所在函数所属对象的引用。换言之，this代本类对象的引用。

当成员变量和局部变量重名，可以用关键字this来区分，this就是所在函数所属对象的引用。

简单说，哪个对象调用了this所在的函数，this就代表哪个对象。一般方法调用默认加this。

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

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

1-5 static关键字

static关键字：
用于修饰成员（成员变量和成员函数）。

被修饰后的成员具备以下特点：
①随着类的加载而加载。

②优先于对象存在。

③被所有对象所共享。

④可以直接被类名调用。

示例：

class Person{
//成员变量，实例变量
String name;
//静态变量，类变量
//所有对象共享的属性用static修饰
static String country = "CN";
public void show(){
System. out.println(country + ":" + name);
//等效语句：System.out.println(Person.country + ":" + this.name);
}
}

class StaticDemo{
public static void main(String[] args){
Person p = new Person();
System. out.println(p.country);
//可以用类名直接调用
System. out.println(Person.country);
}
}

成员变量和静态变量的区别？

1、两个变量的生命周期不同

     成员变量随着对象的创建而存在，随着对象被回收而释放。

     静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

     成员变量只能被对象调用。

     静态变量可以被对象调用，还可以被类名调用。

3、别名不同

     成员变量也称为实例变量。

     静态变量也称为类变量。

4、数据存储位置不同

     成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

     静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

使用注意：

①静态方法只能访问静态成员，如果访问非静态成员，就会报错！
原因：静态方法和变量存在的时候，对象还不存在，非静态变量也不存在，肯定无法访问。

非静态方法既可以访问静态成员，又可以访问非静态成员。
②静态方法中不可以写this，super关键字。
原因：静态方法存在的时候，对象还不存在，this代表的就是调用方法的那个对象，既然不存在，肯定不可以写在静态方法中。
③主函数是静态的
主函数特殊之处：

1、格式是固定的。

2、被jvm所识别和调用。

主函数各成分解析：
public：权限必须是最大的，被jvm调用。

static：不需要对象调用，直接用主函数所属类名调用即可。 命令行窗口中输入：java StaticDemo，实际上就是在执行StaticDemo.main();。

void：主函数不需要具体的返回值。

main：函数名，不是关键字，只是一个jvm识别的固定的名字。

String[] args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

静态什么时候用？

①静态变量

   当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。

   只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

   如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

②静态函数

   函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。

   简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

   如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用。

   如果没有访问特有数据的方法，该对象的创建是没有意义。

静态代码块

随着类的加载而执行，而且只执行一次。
作用：用于给类进行初始化。

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