黑马程序员--java基础--面向对象思想和单例模式

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

面向对象

面向对象：是一种思想，想学好Java必须掌握面向对象。

c语言是一门面向过程的语言，c语言强调的是功能行为。

Java面向对象的思想就是强调具有功能的对象。面向对象是把行动者变成了指挥者。



面向对象的特点：

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

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

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

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

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

类与对象

如图我们可以理解为：类是事物的描述，对象是实体（也可以理解为：类就是图纸，汽车就是对象。）



类：

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

Java是用类class来描述对象的属性和行为，通过new创建对象，即是该类事物实实在在存在的个体。

如何用代码形式创建对象

描述小汽车

分析：
1，属性。
轮胎数。
颜色。
2，行为。
运行。

*/
class Car
{
int num;
String color;

void run()
{
//int num = 10;
System.out.println(num+"..."+color);
}

}

class  CarDemo
{
public static void main(String[] args)
{
//在计算机中创建一个car的实例。通过new关键字。
Car c = new Car();// c就是一个类类型的引用变量，指向了该类的对象。
c.num = 4;
c.color = "red";

c.run();//要使用对象中的内容可以通过  对象.成员 的形式来完成调用。
}

}

成员变量和局部变量

之前我们用到的基本都是局部变量，现在我们将会使用成员变量。其实它两都是变量，规范写法上也没啥区别，都是标识符，但是在作用范围和内存中分配不同。



匿名对象

匿名对象是对象的简化形式，匿名对象两种使用情况。

1、当对对象方法仅进行一次调用的时。

2、匿名对象可以作为实际参数进行传递。

匿名对象。没有名字的对象 。
new Car();//匿名对象。其实就是定义对象的简写格式。
Car c = new Car();
c.run();
new Car().run();

1，当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。

new Car().num = 5;
new Car().color = "green";
new Car().run();

//基本数据类型参数传递
class Demo
{
public static void main(String[] args)
{

int x = 3;
show(x);
System.out.println("x="+x);
}
public static void show(int x)
{
x = 4;
}
}

//引用数据类型参数传递
class Demo
{
int x = 3;
public static void main(String[] args)
{
Demo d = new Demo();
d.x = 9;
show(d);
System.out.println(d.x);
}
public static void show(Demo d)
{
d.x = 4;
}
}

对象的封装



封装的表现形式

（私有）private关键字：权限修饰符，用于修饰类中的成员（成员变量，成员函数）。

私有只在本类中有效。

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

构造函数



构造函数小特点

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

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

构造函数和一般函数区别

构造函数是在对象一建立就运行，给对象初始化。

一个对象建立，构造函数只运行一次。

一般方法是对象调用才执行，给是对象添加对象具备的功能。

一般方法可以被该对象调用多次。

什么时候定义构造函数

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

构造代码块和构造函数的区别：

构造代码块给对象进行初始化。对象一建立就运行。

构造代码块是给所以对象进行初始化。

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

构造代码块中定义的是对象共性的初始化内容。

this关键字

/*
当成员变量和局部变量重名，可以用关键字this来区分。

this : 代表对象。代表哪个对象呢？当前对象。
this就是所在函数所属对象的引用。
简单说：哪个对象调用了this所在的函数，this就代表哪个对象。

this也可以用于在构造函数中调用其他构造函数。
注意：只能定义在构造函数的第一行。因为初始化动作要先执行。
*/

class Person
{
private String name;
private int age;
Person()
{
name = "baby";
age = 1;
System.out.println("person run");
}
Person(String name)
{
this();
this.name = name;
}
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void speak()
{
System.out.println(this.name+":"+this.age);

}

}

this的应用：

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

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

this的两种用法

1、用于区分同名变量的情况，说的成员和局部同名的时候；

2、用于构造函数间调用。

static（静态）关键字



static的特点：

1，static是一个修饰符，用于修饰成员。

2，static修饰的成员被所有的对象所共享。

3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。

4，static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。

5，static修饰的数据是共享数据，对象中的存储的是特有数据

当成员被静态修饰后，可以直接被类名调用。

格式：类名.静态成员

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

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

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

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

2，调用方式不同。

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

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

3，别名不同。

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

静态变量称为类变量。

4，数据存储位置不同。

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

静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

静态使用的注意事项：

1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)

2，静态方法中不可以使用this或者super关键字。

3，主函数是静态的。

什么时候用静态

1，静态变量。

当分析对象中所具备的成员变量的值都是相同的 。

这时这个成员就可以被静态修饰。

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

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

2，静态函数。

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

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

如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，

但是非静态需要被对象调用，而仅创建对象调用非静态的

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

静态代码块：

格式：

static

{

静态代码块中的语句。

}

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

对象的初始化过程：

1、把类名.class文件加载到内存中。

2、执行该类中的static代码块，如果有得话，给该类进行初始化。

3、在堆内存中开辟空间，分配内存地址。给对象

4、在堆内存中建立对象的特有属性。并进行默认初始化。

5、对属性进行显示初始化。

6、对对象进行构造代码块初始化。

7、对对象进行对应构造函数初始化。

8、将内存地址赋给栈内存中的对象名变量。

主函数的构造说明






java中的工具类

每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。

下面我们以一个数组工具类为例，作一个文档说明书。

/**
建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数如：最值，排序等 。
@author 郭
@version
*/

public class ArrayTool
{
private ArrayTool(){}//该类中的方法都是静态的，所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
//可以将构造函数私有化。

/**
获取整型数组的最大值。
@param arr 接收一个元素为int类型的数组。
@return 该数组的最大的元素值
*/
public static int getMax(int[] arr)
{
int maxIndex = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[maxIndex])
maxIndex = x;//
}

return arr[maxIndex];
}
/**
对数组进行选择排序。
@param arr 接收一个元素为int类型的数组。

*/
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
swap(arr,x,y);
}
}
}

/*
用于给数组进行元素的位置置换。
@param arr 接收一个元素为int类型的数组。
@param a
@param b

*/
private static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr;
arr[b] = temp;
}

/**
获取指定的元素在指定数组中的索引.
@param arr 接收一个元素为int类型的数组。
@param key 要找的元素。
@return 返回该元素第一次出现的位置，如果不存在返回-1.
*/
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}

/**
将int数组转换成字符串。格式是：[e1,e2,...]
@param arr 接收一个元素为int类型的数组。
@return 返回该数组的字符串表现形式。
*/
public static String arrayToString(int[] arr)
{
String str = "[";

for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
str = str + arr[x]+", ";
else
str = str + arr[x]+"]";
}
return str;
}
}

在dos命令行中输入命令：javadoc -d Myhelp -author-version ArrayTool.java

[b]Java中的javadoc工具就会帮我们完成API的制作。



单例设计模式

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

单例设计模式的作用：使一个类在内存中只存在一个对象。

步骤：

1、将构造函数初始化。

2、在类中创建一个本类对象。

3、提供一个访问方法可以获取到该对象。

单例设计模式有两种写法（背也要背下来）

1、饿汉式：也就是刚三部中的示例语句。它的特点是先初始化对象。

如：Single类一进内存，就已经创建好了对象。在实际开发中，出于安全考虑，建议使用饿汉式。

class Single
{
private static Single sin=new Single（）； //直接创建对象，比较常用；
private Single（）{}//构造函数私有化，使其他类中不能创建该类对象。
public static Single getInstance（）//括号里面可以写入条件，从而实现可控性。
{
return sin；
}
}

2、懒汉式：它的特点对象是方法被调用时，才初始化，这也叫对象的延时加载。

如：在以下完整代码中，Single类进内存，对象还没有存在，只有调用了getInstance()方法时，才创建对象。

class Single
{
private static Single sin=null; //这里就是体现出懒汉，初始值定义为空，被调用时才创建对
private Single（）{}//构造函数私有化，使其他类中不能创建该类对象。
public static Single getInstance（) //括号里面可以写入条件，从而实现可控性。
{
if（sin==null）
sin=new Single（）；
return sin；
}
}