学习笔记 Java_静态_继承 2014.7.12

最新推荐文章于 2014-08-06 19:08:04 发布

makeEffort

最新推荐文章于 2014-08-06 19:08:04 发布

阅读量633

点赞数

分类专栏： Java SE

本文链接：https://blog.csdn.net/a520bc/article/details/37722973

版权

Java SE 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

一、静态

1、构造函数：
      特点：
      1、函数名和类名相同。
      2、不用定义返回值类型（和void不是一回事，而构造函数是根本不用定义返回值类型）。
      3、不可以写return语句。
      对象一建立就会调用与之对应的构造函数。
      构造函数的作用：可以用于给对象进行初始化。（我们现实生活中的事物，只要一出现就具备的特性。比如：人一出生就会哭，一初始化就会哭，哭就是这个人的行为）
      构造函数的小细节：
      1、当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
      2、当在类中自定义了构造函数后，默认的构造函数就没有了。
      构造函数和一般函数在写法上有不同。
      在运行上也有不同：
      1、构造函数是在对象一建立就运行。给对象初始化。
            而一般方法是对象调用才执行，是给对象添加对象具备的功能。
      2、一个对象建立，构造函数只运行一次。
            而一般方法可以被对象调用多次。
      方法都是被对象调用（在没学静态之前）
     什么时候定义构造函数呢：
      当分析事物时，该事物存在就具备一些特性或者行为，那么将这些内容定义在构造函数中。

2、主函数：public static void main(String[] args) //arguments
    主函数是一个特殊的函数。作为程序的入口，可以被jvm调用。
     主函数的定义：
     public：代表着该函数访问权限是最大的。
     static；代表主函数随着类的加载就已经存在了。
     void：对主函数没有具体的返回值。
     main：不是关键字，但是是一个特殊的单词，可以被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  
/*
关键字extends，就可以让学生和Person产生点关系。学生就是Person的子类，Person就是学生的子类。Person也叫做超类、基类。

Java语言中：java只支持单继承，不支持多继承（即一个类可以继承多各类，这个说得不严谨）。java不支持多继承的好处就是优化了C++的部分，因为C++支持。
比如：Student继承了Person类就不能继承其他类了

因为多继承容易带来安全隐患：
当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。
但是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
	}
}