day03.txt

达内科技上课的 java学习笔记 分为18天学完

					CoreJava(day03)  2007-12-5   --- 李艳


面向对象：
	
	1、类：同一类事物的抽象的定义，对象的抽象，客观对象在人脑中的主观反映。对象的模版

	2、对象：类的个体（实现），客观存在的一切事物都是对象，有什么（属性），能做什么（方法）。对象有可能被实例化，也有可能不被实例化。
	   实例（instance）：实现了的对象

		例：Student s;   //Student是类，s是对象
	    	    s=new Student();  //new Student()是实例   

	3、规范：

	    	package 包名;  0--1个            包名全小写，各单词之间用.隔开
	    	import 要导入的包路径;  0--n个
	    	class 类名{    
	     		field;  //属性  0--n
	     		构造方法;   //0--n   在编译后的文件中是1--n个
             		方法;      //0--n
  	   	}
		
		package;
		import;
		class;  
		这三个顺序不可改变

		类的定义格式：	[修饰符(0--n)] class 类名{}

		属性的定义格式：[修饰符] 类型 属性名;

		方法的定义格式：[修饰符] 返回类型 方法名 参数表 [异常] {} 

		容易出现的错误：class T{
				   	private String name;

				   	System.out.println(name);   //这句位置错误，因为在类体内只允许放属性、构造器、方法和语句块，不允许出现语句。

				   	{
					    System.out.println(name);  //这是正确的，因为是放在了语句块里，被大括号包围起来的多行代码称为语句块。
				   	}
				}
		
		java中所有的参数类型传递都是值传递，基本类型传递变量中确切的值，引用类型传地址。

	4、this的使用
		
		this不能出现在静态(static)方法中。

		两种用法：
			1)用来区分实例变量与局部变量的冲突  
 
			例:public setName(String name){
				this.name=name;     
			   }

			2)this();在构造器里这样写表示调用本类的其它构造器，必须放在此构造器的第一行。
			  this(name);   小心循环调用造成死循环


	5、面象对象的三大特性：封装，继承，多态

		a)封装(Encapsulation)：（课堂代码：Person.java,TestPerson.java）

			封装，一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。

  		       （对象的属性应当隐藏），一个对象的内部是透明的，就是把对象内部的可透明性和隐藏的特性区分开，该透明的透明，该隐藏的隐藏。

  		       （封装的属性）java中类的属性的访问权限的默认值不是private，
					要想隐藏该属性或方法，就可以加private（私有）修饰符来限制只能够在类的内部进行访问。

   			对于类中的私有属性，要对其给出一对方法（getXxx(),setXxx()）访问私有属性，保证对私有属性的操作的安全性。
   			
			方法公开的是方法的声明（定义），即（只须知道参数和返回值就可以调用该方法），封装会使实现的改变对架构的影响最小化。

  		 	完全的封装，类的属性全部私有化，并且提供一对方法来访问属性。给自己用的方法要隐藏                                              
         
   			Java Bean 一种组件规范 --> 所有属性私有，访问方法按照命名规范setXxx(),getXxx(),isXxx()方法

       		b)重载:(Overload): （课堂代码：Calculator.java）

			方法名相同，参数表不同，可能相同的返回类型，又叫编译时多态
			
			方法是否重载与返回类型无关。
			
			参数列表必须不同是为了查找、调用不同的方法，虚拟机按照参数的类型与个数来进行方法的调用。

	  		重载是为了屏蔽对象同类方法由于参数表不同所造成的差异，这个差异对使用者是屏蔽的

      	  		向上就近匹配原则（当有多个参数时，选择少提升的参数）（课堂代码：TestOverload.java）

		API中方法名的规范：获取某个属性的内容getXxx()，设置属性的值setXxx(),判断是不是isXxx(),返回boolean类型

       6、构造器：（课堂代码：Emp.java）
		
		定义构造器的格式：[修饰符] 类名([参数]){
					语句
				  }

		构造器无返回类型，方法名与类名相同，既方法名固定为类名。
				
				     			     实例化
		构造器是为了完成由类到对象实例化的过程：类---------->对象  ，（new 构造器）

		构造器的功能是为了创造对象，方法是为了操作对象。

		一般把初始化的代码放在构造器里
		
		package----->分配目录
		import------->导入目录下的文件，引入哪个包里的哪个类文件。import的来源是CLASSPATH（类路径）

	        	例：import mypack.Welcome;   声明以下用到Welcome时不带包名 
		
			    import mypack.*;    *表示mypack包下的所有类，不能表示子包

		class 的声明：
			class 类名{
				属性: 类的特征，在命名时用名词表示
				构造器：实现，表示如何实例化类，生成一个具体的对象
				方法：标识对象的行为，在命名时使用动宾短语
			}

		类的使用：new 一个类的构造器，得到该类的对象，用对象.属性/方法去执行代码

		创建对象格式：类名 对象名=new 类名（参数表）

			例：int a; //简单变量
	  		    Student s；  //声明一个Student类的对象变量（或称引用）
    			    s = new Student();  //调用Student类的无参的构造方法，创建一个对象,把这个对象的地址赋给一个Student类的引用
    						（引用指向了这个对象，引用中保存对象的首地址，以后都是通过引用访问这个对象的属性和方法）
    			    s.age    s引用指向对象的age属性

		构造器可以重载，构造器是由系统自动调用的

		若对一个类没有写构造器，则构造对象时会自动调用默认的无参的空的构造器，但要求最好自己写构造方法，不要依赖默认的构造方法
		
		若自己写了任何一个构造器，系统便不再提供无参的空的构造器
          
		java中没有析构方法，也不允许程序员自己定义析构方法，因为java中有自动垃圾收集器

		
	7、继承
		继承，是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父类。父类的意义在于可以抽取多类事物的共性。

  		泛化：把共性从子类中抽取出来。先有子类后有父类叫泛化

    		特化：先有父类，再有子类的过程。先有父类再有子类叫特化

   		父类与子类 -> 从一般到特殊的关系

   		java中的继承要使用extends关键字，并且java中只允许单继承，也就是一个类只能有一个直接的父类。

   		这样就是继承关系呈树状，体现了java的简单性。

   		子类只能继承在父类中可以访问的属性和方法（实际上父类中私有的属性和方法也会被继承但子类中无法访问罢了）。

		注意：构造器不能被继承。

   		实际上一个子类对象中包含一个父类对象
		
		继承的意义，就在于子类可以在父类的基础之上对父类的功能进行发展,继承可以使系统的耦合性降低，
			    也就是使对象间的联系便的松散，使多类对象间的联系用其父类对象代替。	
	
	8、super关键字

  		(1)区分父子类间的属性遮盖和方法覆盖，用来区分被子类遮盖的实例变量和被子类覆盖的方法，父子类之间的属性相同时会形成遮盖

  		(2)super()，表示在子类的构造方法中调用父类的构造方法（可以通过这种方法在子类的构造方法中初始化父类中的属性），
		   super()也只能出现在构造方法的第一句上。super(),在子类的构造方中指明构造父类时调用哪一个父类的构造方法构造父类。
  		   super. 这里所表示的是一个父类的对象，可以通过super来使用父类中可以访问的方法
			（可以在父类中定义setXxx()，getXxx()方法来访问父类中的私有属性），super可以屏蔽父子类中同名属性的冲突。 
 
  		注意：在写类的时候，一定要写默认无参的构造方法，如果一个构造方法的第一句既不是this(),也不是super()时，
			那么就会在这里隐含的调用他的父类的无参的构造方法，即隐含的有super()。
		      this()和super()不能在同一个构造器中出现，因为都必须出现在第一行。既“一山不容二虎”
		      所有的对象的构造都是先父后子，先调用this的东西，后调用super的东西.

	9、多态：
	
		java中的多态 --- 运行时多态
		Person p=new Student();  //Person 是编译时类型，Student是运行时类型。运行时类型得是编译时类型的子类
   		引用类型      对象类型
   		主观类型      客观类型
	
		父类的引用赋值给子类的引用需要强制类型转换，而子类的引用赋值给父类的引用不需要强制类型转换

		多态的用途：可以把不同子类的对象统一当做父类对象来看，屏蔽不同子类的差异
	    		多态可以使代码变得更通用，以适应需求的变化。也就是定义在父类中的方法，可以在子类中有不同的实现将其覆盖，
	       		在为父类型的对象变量赋值相应需要功能的子类的对象实例。

	   多态的种类:

		a)简单类型的多态
		b)方法的多态
		c)参数的多态
		d)类的多态: Person p=new Student();

		instanceof的用法: 引用 instanceof 类名----判断该引用所指向的对象和后面的这个类是否兼容，用在强制类型转换之前。

		 p instanceof Student;    //p指向的对象是不是Student类
   		一般用在强制类型转换之前，避免转换异常
		
		if(p instanceof Person)  返回true ，因为向上兼容
		
	10、方法的重写（也叫方法覆盖）：重写一定要有继承关系，重载不需要继承关系
		
		java中方法的覆盖-----父子类之间 
			1)重写的要求：子类与父类的方法名相同，参数表相同，返回类型相同，不能抛出比父类更大的异常
			2)需要重写的子类方法的修饰符要比父类被重写方法的修饰符相同或更宽

  		注意：在jdk1.4以前要求方法的覆盖时，需要方法的返回值，参数表，方法名必须严格相同，
			而在jdk1.5中方法覆盖，子类的中覆盖的方法的返回值可以是父类中被覆盖的方法的返回值类型的子类型。

  		注意：子类的方法覆盖父类的方法时，方法的修饰符要么相同，要么子类中的方法的修饰符表示的访问权限要大于父类。
			父类中的私有方法，不能被继承到子类，就是说子类中即使将其覆盖了也不会有多态。    
     
  		注意：父子类中有同名的属性不叫子类覆盖了父类的属性，这种情况叫作属性的遮盖（shadow）。

	  参考书：java核心技术
		
	作业：写一个日期类(Mydate): 私有化属性（用封装）
			int year;
			int month;
			int day;
		对每个属性给出set,get方法,其中setYear：1900---2100之间，setMonth:1-12之间
			                      setDay:1,3,5,7,8,10,12:31天，
							4，6，9，11：30天，
							2：28天或者29天？看是否闰年：year%4==0&& year%100!=0||year%400==0
		写两个构造器，一个无参，一个参数表是(int y,int m,int d)