黑马程序员—面向对象：从略知一二到深入了解（二）

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

今天开始第二天的学习，还是继续学习了面向对象的知识，毕老师在上课的开始讲了关键字static. 要分清楚对象的数据是不是被共享的，是的话使用static关键字比较合适。

用法：是一个修饰符，用于修饰成员（成员变量，成员函数）

当成员背静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。

格式：类名.静态成员

static的特点：

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

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

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

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

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

静态使用的注意事项：

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

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

3.主函数是静态的。

再讲注意事项的时候老师又强调了他上节课所说的，简单的方法必定有它的局限性！

成员变量和静态变量的区别？
1.两个变量的生命周期不同。

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

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

2.调用方式不同。
  成员变量只能被对象调用。
  静态变量可以被对象调用，还可以被类名调用。

3.别名不同。
  成员变量也称为实例变量。
  静态变量称为类变量。 

4.数据存储位置不同。
  成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
  静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

下面是一段关于static这个知识点的一段代码，很典型的一个例子：

class Person
{
//成员变量，实例变量
String name;
//静态变量。类变量
static String country = "CN";
public  void show()
{
System.out.println(Person.country+":"+this.name);
}
}

class StaticDemo
{
int num = 4;
public static void main(String[] args)
{
Person  p = new Person();
p.name = "小强";
p.show();
//		System.out.println(p.country);     应该以下一行的方式进行访问
System.out.println(Person.country);
//		Person.show();非静态方法show（）  不能够进行静态引用
new StaticDemo().show();
}

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

什么时候使用静态？

要从两个方面下手：

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

什么时候定义静态变量（变量类）呢？

当对象中出现共享数据时，该数据被静态所修饰。

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

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

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

接下来老师详细介绍了主函数，从每个关键字（main不是关键字，但是是一个特殊的单词，可以被Jvm识别）逐一讲解。



Jvm在调用主函数时传入的new String[0]。
构造函数的知识：

写法特点：

1.函数名和类名相同。

2.不需要定义返回值类型

3.没有具体的返回值。但是有return语句，用于结束构造函数。

使用特点：

1.定义类中，有默认的空参数构造函数。如果已经自定义，那么默认就没有了。

2.构造函数在类有多个，是重载形式体现出来的。

构造函数的作用：

用于给对象进行针对性的初始化。

设计模式：对问题行之有效的解决方式。其实它是一种思想。

在java中有23中设计模式，老师举了一个单例设计模式

单例设计模式：

解决的问题：就是可以保证一个类在内存中的对象唯一性。

必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证对象唯一性呢？

1.不允许其他程序用new创建该类对象。

2.在该类创建一个本类实例。

3.对外提供一个方法让其他程序可以获取该对象。

步骤：

1.私有化该类构造函数。

2.通过new在本类中创建一个本类对象。

3.定义一个公有的方法，将创建的对象返回。

单例模式又有两个模式：饿汉式和懒汉式（名字很形象很好记啊！）

//饿汉式
class Single //类一加载，对象就已经存在了。
{
private static Single s = new Single();
private Single(){}

public static Single getInstance()
{
return s;
}
}

//懒汉式
class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
//延迟加载形式。
{
private static Single2 s = null;
private Single2(){}
public static Single2 getInstance()
{
if(s==null)
s = new Single2();
return s;
}
}

class  SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
System.out.println(s1==s2);
//		Single ss = Single.s;
//		Test t1 = new Test();
//		Test t2 = new Test();
Test t1 = Test.getInstance();
Test t2 = Test.getInstance();
t1.setNum(10);
t2.setNum(20);
System.out.println(t1.getNum());
System.out.println(t2.getNum());
}
}

class Test
{
private int num;

private static Test t = new Test();
private Test(){}
public static Test getInstance()
{
return t;
}
public void setNum(int num)
{
this.num = num;
}
public int getNum()
{
return num;
}

}

在面试的时候会问到懒汉式，但是开发时一般用饿汉式，比较安全。

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

详细请查看：http://www.itheima.com/