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

 

 

 

 

 

 

 

 

 

posted @ 2017-06-17 15:00  yfceshi  阅读(176)  评论(0编辑  收藏  举报