学习笔记 Java_静态_继承 2014.7.12

一、静态

1、构造函数：

      特点：

      1、 函数名和类名同样。

      2、 不用定义返回值类型（和void不是一回事，而构造函数是根本不用定义返回值类型）。

      3、 不能够写return语句。

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

      构造函数的作用：能够用于给对象进行初始化。（我们现实生活中的事物，仅仅要一出现就具备的特性。

比方：人一出生就会哭，一初始化就会哭，哭就是这个人的行为）

      构造函数的小细节：

      1、当一个类中未定义构造函数时，那么系统会默认给该类增加一个空參数的构造函数。

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

      构造函数和一般函数在写法上有不同。

      在执行上也有不同：

      1、 构造函数是在对象一建立就执行。

给对象初始化。

而一般方法是对象调用才运行。是给对象加入对象具备的功能。

2、 一个对象建立。构造函数仅仅执行一次。

            而一般方法能够被对象调用多次。

方法都是被对象调用（在没学静态之前） 

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

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

2、主函数：public static void main(String[] args)  //arguments

     主函数是一个特殊的函数。作为程序的入口，能够被jvm调用。

主函数的定义：

     public：代表着该函数訪问权限是最大的。

static；代表主函数随着类的载入就已经存在了。

void：对主函数没有详细的返回值。

     main：不是keyword，可是是一个特殊的单词，能够被jvm识别。

     (String[] arr)：函数的參数。參数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

     主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String[0] ：

class test
{
	public static void main(String[] args) //new String[]
	{
		System.out.println(args);  //得[Ljava.lang.String;@1175422
		System.out.println(args.length);  //得0
	}
}

//args仅仅能接收两种值
//String[] args = new String[3];
//String[] args = null;

3、什么时候使用静态？

    要从双方面下手：

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

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

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

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

    什么时候定义静态函数：

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

4、静态的应用：

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

 尽管能够通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。发现了些问题：

 1、对象是用于封装数据的。但是ArrayTool对象并未封装特有数据。

 2、操作数组的每个方法都没实用到ArrayTool对象中的特有数据。

 这时就考虑，让程序更严谨，是不须要对象的。能够将ArrayTool中的方法都定义成static的，直接通过类名调用就可以。

 将方法都静态后。能够方便于使用，可是该类还是能够被其它程序建立对象的。为了更为严谨，强制让该类不能建立对象。能够通过将构造函数私有化完毕，即private ArrayTool(){}

5、静态代码块

 格式：

 static

 {

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

 }

 特点：随着类的载入而运行，仅仅运行一次。

用于给类进行初始化的。

6、Person p = new Person("zhangsan", 20);

 该句话做了什么事情：

 1、由于new用到了Person.class，所以会先找到Person.class文件并载入到内存中。

 2、运行该类中的static代码块，假设有的话。给Person.class类进行初始化。

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

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

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

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

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

8、将内存地址赋给栈内存中的p变量。

7、设计模式：

 解决某一问题最行之有效的方法。

 java中23种设计模式：

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

 想要保住对象唯一：

 1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。

 2、还为了让其它程序能够訪问到该类对象。仅仅好在本类中，自己定义一个对象。

 3、为了方便其它程序对自己定义对象的訪问，能够对外提供一些訪问方式。

 这三步怎么用代码体现呢：

 1、将构造函数私有化。

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

 3、提供一个方法能够获取到该对象。

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

 饿汉式——懒汉试null（面试懒汉问得最多，问怎么解决这个问题。多线程也考到了synchronized。复合型比較高）

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

二、继承

1、继承概述：

代码：test.java

class Person
{
	String name;
	int age;
}

class Student extends Person
{
	void study(){}
}

class Worker extends Person
{
	void work(){}
}

class test
{
	public static void main(String[] args)
	{
		Student s = new Student();
		s.name = "zhangsan";
		System.out.println(s.name);  //得zhangsan   嘿，为啥子如今不用toString都能够正常输出了呀？
	}
}

代码：ExtendsDemo.java

class Person  //将学生和个人的共性描写叙述提取出来，单独进行描写叙述。仅仅要让学生和个人与单独描写叙述的这个类有关系(extends)。就能够了
{
	String name;
	int age;
}

	/*
	继承：
	1、提高了代码的复用性。

2、让类与类之间产生了关系。

有了这个关系，才有了多态的特性。

注意：千万不要为了获取其它类的功能，简化代码而继承。

必须是类与类之间有所属关系（Student is a Person.）才干够继承。

举个样例：

	class C  //C是找到A和B的共性内容，抽取的
	{
		void demo1(){}
	}

	class A extends C
	{
		//void demo1(){}
		void demo2(){}
	}

	class B extends C
	{
		//void demo1(){}  //A和B里面都有demo1()，就如果B继承A，B就拿到了A的demo1方法。但同一时候也拿到了demo2()，思考B应该拿到demo2()吗。不应该。那么它们之间没有继承关系。

那他们确实有一样的demo1()呀，我们就加个C，去继承C。
		void demo3(){}
	}

	*/
class Student extends Person
/*
keywordextends，就能够让学生和Person产生点关系。学生就是Person的子类，Person就是学生的子类。Person也叫做超类、基类。

Java语言中：java仅仅支持单继承，不支持多继承（即一个类能够继承多各类。这个说得不严谨）。

java不支持多继承的优点就是优化了C++的部分，由于C++支持。

比方：Student继承了Person类就不能继承其它类了

由于多继承easy带来安全隐患：
当多个父类中定义了同样功能，当功能内容不同一时候，子类对象不确定要执行哪一个。
可是java保留这样的机制，并用还有一种体现形式来完毕表示：多实现（java对多继承的改良）。

java支持多层继承（C继承B。B继承A 祖孙三代）。也就是一个继承体系。

怎样使用一个继承体系中的功能呢：
想要使用体系，先查阅体系父类的描写叙述，由于父类中定义的是该体系中的共性功能。
通过了解共性功能，就能够知道该体系的基本功能。
那么这个体系已经能够基本使用了。

那么在详细调用时，要创建最子类的对象。为什么呢：
一是有可能父类不能创建对象（比方抽象类），二是创建子类对象能够使用很多其它的功能，包含主要的也包含特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。

Class A
{
	void show()
	{
		System.out.println("a");
	}
}

Class B
{
	void show()
	{
		System.out.println("b");
	}
}

class C extends A, B
{}

C c = new extends A, B;
c.show();  //问：打印的是a还是b呀，是不是不确定呀。

*/
{
	void study()
	{
		System.out.println("good study");
	}
}

class Worker extends Person
{
	void work()
	{
		System.out.println("good work");
	}
}

class ExtendsDemo
{
	public static void main(String[] args)
	{
		Student s = new Student();
		s.name = "zhangsan";
	}
}

对象与对象之间或者类与类之间或者说事物间不光继承这一种关系

 聚集：has a （一般用聚集关系比继承还要多）

 1、聚合：（球员是球队中的一个。球队中有球员）

 2、组合：事物间联系更紧密（手是人身体的一部分。心脏是人身体的一部分）

2、子父类中变量的特点：

代码：ExtendsDemo2.java

class Fu
{
	int num1 = 4;
}

class Zi extends Fu
{
	int num2 = 5;
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		System.out.println(z.num1 + "....." + z.num2);  //得4.....5
	}
}

代码：ExtendsDemo2.java

class Fu
{
	int num = 4;
}

class Zi extends Fu
{
	int num = 5;
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		System.out.println(z.num + "....." + z.num);  //得5.....5  子类和父类的变量一样。调用子类的
	}
}

代码：ExtendsDemo2.java

class Fu
{
	int num = 4;
}

class Zi extends Fu
{
	int num = 5;
	void show()
	{
		System.out.println(num);  //num前省略了this.（this表示本类对象的引用，訪问本类的成员变量和成员方法）
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();  //得5
	}
}

代码：ExtendsDemo2.java

class Fu
{
	int num = 4;
}

class Zi extends Fu
{
	//int num = 5;  //假设把这句话注视掉
	void show()
	{
		System.out.println(num);  //这里就省略了super.
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();  //得4
	}
}

代码：ExtendsDemo2.java

/*
子父类出现后，类成员的特点：

类中成员：
1、变量
2、函数
3、构造函数

1、变量
假设子类中出现非私有的同名成员变量时，
子类要訪问本类中的变量，用this
子类要訪问父类中的同名变量，用super

super的使用和this的使用差点儿一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。

*/
class Fu
{
	int num = 4;
}

class Zi extends Fu
{
	//int num = 5;  //假设把这句话注视掉
	void show()
	{
		System.out.println(this.num);  //这里加上this.   num还是4
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();  //得4
	}
} 

代码：ExtendsDemo2.java

class Fu
{
	private int num = 4;
	public void setNum(int num)
	{
		this.num = num;
	}
	public int getNum()
	{
		return this.num;
	}
}

class Zi extends Fu
{
	void show()
	{
		System.out.println(num);  //num私有化了，怎么訪问num呢？
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();
	}
}

3、子父类中函数的特点：

代码：ExtendsDemo3.java

class Fu
{
	void show1()
	{
		System.out.println("fu show");
	}
}

class Zi extends Fu
{
	void show2()
	{
		System.out.println("zi show");
	}
}

class ExtendsDemo3
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show1();  //得fu show
		z.show2();  //得zi show
	}
}