学习笔记 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

	}

}

巴特西

学习笔记 Java_静态_继承 2014.7.12

最新文章

热门文章