黑马程序员_面向对象

 
 


 
 
 
 

  
  ------------- 
  
  android培训
  
  、
  
  java培训
  
  、java博客、java学习型技术博客、期待与您交流！ -------------
 
 
类的基本形式
	对象
		对象是现实世界中存在的事物，可以是生物、物品等具体事物，也可以是计划、交易等抽象事物。
		对象特征可分为静态特征（外观、属性）和动态特征（功能、行为）。
		将对象的静态特征抽象为属性，用数据来描述，在Java语言中称为变量；
		将对象的动态特征抽象为行为，用一组代码来表示，完成对数据操作，在Java中称为方法。
	
	类
		具有相同属性及行为的一组对象称为类，也就是说类是具有共同性质的事物的集合。
		在Java中，类是一种抽象数据类型，它不但包括数据，还包括方法。
		既然类是一个抽象概念，要利用类的方式来解决问题，必须用类创建一个实例化的类对象，
		然后通过类对象去访问类的成员变量、调用类的成员方法来实现程序的功能。
		对象的抽象就是类，类的具体化就是对象。

	匿名对象
		没有具体对象名称引用它。调用函数，new 类名().函数名();	
		当对对象方法仅进行一次调用的时候，可以使用匿名对象，书写较简化；
		如果对一个对象进行多个成员调用，必须给对象起名字；
		匿名对象可以作为实际参数进行传递，new 类名();

	封装(Encapsulation)
		指隐藏对象的属性和实现细节，仅对外提供公共访问方式
		便于使用：不用了解内部构造，只要知道名称、有什么功能、返回结果，就可以完成应用；
		提高安全性：类数据被隐藏，防止了对类的修改和随意访问；
		
	private关键字
		私有，权限修饰符，用于修饰成员变量、成员函数，私有成员只在本类中调用有效；
		类中某些方法是不需要对外提供的，所以将其私有；
		类中变量是用于存储数据的，直接访问，存在安全隐患，所以将其私有化，
		而对外提供访问方法，方法中可以自定义一些逻辑判断等语句，提高代码健壮性；
		通常情况下，类中成员变量都需私有，且附带着set和get两个公共访问方法；
		私有成员一般情况下不能被外部访问，但是通过反射方式可以强行访问。
	
	构造函数
		函数名与类名相同、不用定义返回值类型、不可以写return语句；
		类名(){...};对象一建立就会调用与之对应的构造函数；
		作用：就是给对象进行初始化；因为许多事物一出现就会有相应的属性或行为；
		注意：当一个类中没有定义构造函数时，系统默认给类加入一个空参数构造函数；
			  当在类中自定了构造函数后，默认构造函数就没有了；
			  多个构造函数是以重载形式存在。
		构造函数与一般函数区别
			格式写法不同；
			构造函数是在对象一建立就运行，给对应对象初始化，且只运行一次；
			一般函数只在对象调用才会执行，可调用多次。
	构造代码块
		格式： {...}    定义的是该类不同对象共性的内容；
		对象一建立就运行，而且优先于构造函数执行；
		构造代码块是给所有对象进行统一初始化，
		而构造函数是给对应对象初始化；
	
	this关键字
		this代表本类对象，即哪个对象调用this所在的函数，this就代表这个对象；
		当定义类中功能时，函数内部要用到调用该函数的对象时，用this表示这个对象，
		1、用于区分变量出现同名情况，成员变量与局部变量同名；
		2、this语句用于构造函数间互相调用，类名(...) 需写成 this(...)		
		注意：this语句只能定义在构造函数的第一行。
	
	static关键字
		修饰符，用于修饰成员变量和成员函数，可用类名.静态成员直接调用；
		1、静态成员都存储在方法区（或共享区），随着类的加载而加载，随着类的消失才消失；
		   因此其优先于对象而存在，所以静态方法只能访问静态成员，且生命周期较长；
		   还有静态中不可以有this、super关键字。		
		2、类变量即静态变量，存储于方法区中，生命周期与类对应；对象的共享数据；
		   对象变量即成员变量存储于堆内存中，生命周期与对象对应；对象的特有数据；
		3、什么时候定义静态呢？分变量和方法两种情况；
			对象中出现的共享数据可定义静态，特有数据则定义非静态；
			对象中功能没有访问特有数据，那么该功能可定义成静态；
			程序都有很多共性功能，可将这些功能抽取出来独立封装，方便直接调用；如Collections类；
	static代码块
		static{执行语句；}		
		特点：随着类的加载而执行，只执行一次。
		作用：用于给类进行初始化的。
		明白：    静态代码块		    给类进行初始化
			  构造代码块		    给对象初始化
			  构造函数	            给对应对象初始化

	对象的初始化过程	先后顺序(方法区存储静态成员和方法)
		1、new对象，jvm先找该类并将其加载到内存中
		2、执行该类中 static 代码块，给类进行初始化
		3、在堆内存中开辟空间、分配内存地址
		4、在堆内存中建立对象的特有属性，并进行默认初始化
		5、对属性进行显示初始化
		6、对对象进行构造代码块初始化
		7、对对象构造函数初始化
		8、将内存地址付给栈内存类变量		
		另：父类静态变量—>父类静态代码块—>子类静态变量—>子类静态代码块—>父类非静态变量—>
		父类非静态代码块—>父类构造方法—>子类非静态变量—>子类非静态代码块—>子类构造方法。

继承
	
	继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力；
	继承表达的就是一种对象类之间的相互关系，可用父类和子类描述，父类为子类的一般化，子类为父类的具体化；

	继承特征
		1、继承关系式可传递的，C继承B,B继承A，C具备B和C的属性和行为，也可由自定义属性和行为；
			继承是在一些比较一般的类基础上构造、建立和扩充新类的最有效手段。
		2、继承大大提高复用性，若B继承A，那么建立B类时只需描述与A类不同的特征即可；
		3、继承通过增强一致性来减少模块间的接口和界面，增加了程序的易维护性；
		4、java出于安全和可靠方面考虑，仅支持单继承，但可通过接口机制实现多继承（多实现）；
		5、继承简化了对事物的描述，能清晰体现相关类间的层次结构关系。
	
	子父类成员特点
		变量：子父类中非私有成员变量，子类访问本类的用this.变量名;访问父类的用super.变量名；
		函数：子父类中有同名函数，即子类函数复写父类函数，子类保留父类函数功能，但功能内容不同；
		      注意 子类覆盖父类必须保证子类权限大于等于父类权限，否则编译失败；静态不能覆盖非静态；
		      重载：只看同名函数的参数列表； 重写：子父类方法要一模一样。
		构造函数：
			1、子类所有构造函数默认第一行有一条隐式的语句：super()，它会访问父类中空参数的构造函数；
			   当父类中没有默认空参数构造函数时，子类必须指定访问父类构造函数；
			   因为子类继承父类时直接获取父类所有数据，它需要知道父类是怎么对这些数据进行初始化的。
			2、子类构造函数可以定义this()访问本来其他构造函数，但是必有一个构造函数第一行有super().
		总结：父类中有的成员，子类需使用，可以super.变量名、super.函数名(),子类不用自定义了；
			  查阅父类描述，了解功能，创建子类对象，使用功能。

	final关键字
		修饰符，可修饰类、变量、函数
		类：被final修饰的类不可以被继承，继承破坏了封装性，对不想被继承的类，可用final修饰。
		函数：被final修饰的函数不可以被复写；
		变量：被final修饰的变量只能被赋值一次，一些变量值是固定的，取名+final修饰，增强阅读性；
		内部类定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。

	抽象类
		当多个类中出现相同功能，但是功能内容不同，这时可以只抽取功能定义，而不抽取功能内容
		特点：
			1、抽象方法一定在抽象类中
			2、抽象方法和抽象类都必须由关键字abstract修饰
			3、抽象类不可以用new建立对象，因为调用抽象方法没意义，只能由其派生出的子类来new对象
			4、抽象类中的方法要被使用，必须由子类复写所有抽象方法，如果没有全部覆盖，则子类仍为抽象类
			5、抽象类与其它类一样，有构造函数、变量和属性，只是多了抽象方法，少了创建对象部分
			6、抽象类中可以不定义抽象方法，就是让该类不被创建对象
			7、抽象关键字abstract与哪些不可以共存，final、private、static
	
	接口
		初期理解，可以认为是一个特殊的抽象类，当抽象类中方法都是抽象的，就可以用接口表示；
		class定义类，类与类关系是继承，因为父类有具体功能对象，子类继承可以直接用；
		抽象类，一般用于描述一个体系单元，定义的都是一个体系中的基本内容；接口一般定义扩展内容或功能；
		interface定义接口，接口与类是实现关系，接口没具体功能，只有将接口抽象方法全部复写，才能实现使用
		特点：
			1、接口中成员，全局常量和抽象方法，
			2、接口中成员都有固定修饰符，常量：public static final 方法：public abstract
			3、接口成员都是public的，抽象类是可以自定义权限的
			4、接口与类之间可以多实现，因为接口内方法抽象，一个类在继承的同时还能实现多个接口
			5、接口与接口之间是继承关系，可多继承
			6、子类实现接口，必须复写接口所有方法，才能被实例化，否则是一个抽象类
		特征：(举例Runnable)
			1、对外提供的规则；  需复写run方法
			2、功能的扩展；      相当于是为其它类建立多线程功能提供途径；
			3、降低耦合性；      各个程序只要实现它就可以建立多线程

多态
	
	事物存在多种形态，函数重载是多态的一种体现，对象也具备多态性

	表现形式
		父类引用或者接口的引用指向了自己的子类对象。如，Animal a = new Cat();
		或父类的引用接受自己的子类对象。

	前提
		必须有关系，要么继承要么实现
		存在覆盖，即父类中有该功能，各子类有覆盖，
		只能使用父类的引用访问父类的成员，

	好处
		大大提高了程序的拓展性
	弊端：
		当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，
	        不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)
	
	转型
		Animal a = new Cat();类型提升，向上转型；
		Cat c = (Cat)a ; 强制将父类的引用转成子类对象，向下转型；
		向下转型后，就可以调用子类对象特有成员了；
		instance关键字，判断是否是同一个对象，(A instanceof B)
		注意：能强转的是将父类的引用指向了子类对象，该引用可以被转换；
		      如果new一个动物，要转换成猫就不可以。
	
	注意事项
		多态出现后代码中的特点
		1，成员变量：在多态中，子父类成员变量同名。
			简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。
			成员变量    编译运行都看  左边。
		2，成员函数。
			编译时期：参考引用型变量所属的类中是否有调用的方法。
			运行事情：参考的是对象所属的类中是否有调用的方法。
			为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。
			简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。
			成员函数    编译看  左边，运行看  右边。
		3，静态函数。 
			因为静态方法，其实不所属于对象，而是所属于该方法所在的类。
			调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。
			静态函数  编译运行都看  左边。
		总结，除了复写的非静态函数，父类引用指向子类对象，执行的是子类方法，其他都是父类的。


	内部类
		如果A类需要直接访问B类中的成员，而B类又需要建立A类的对象。这时直接将A类定义在B类中。
		定义：将一个类定义在另一个类的里面，该类叫做内部类
		访问规则：
			1、内部类可以直接访问外部类中的成员，包括私有，(this.)
			内部类成员之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用(类名.this)
			2、外部类要访问内部类，必须建立内部类对象	
		访问格式：
			当内部类定义在外部类的成员位置上时且非私有，可以在其他类直接建立该内部类对象
			外部类名.内部类 变量名 = new外部类（）.new内部类（）;
			Outer.Inner in = new Outer().new Inner();
		内部类定义在局部时
			不可以被成员修饰符修饰
			可以直接访问外部类中的成员，因为还持有外部类中的引用
			但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量
		内部类在成员位置上，就可以被成员修饰符所修饰
			例如，private：将内部类在外部类中进行修饰；注，外部类不能被私有
			      static：内部类就具备了静态特性	  
			外部其他类直接访问static内部类的非静态成员
				new  Outer.Inner().function();
			外部其他类直接访问static内部类的静态成员
				Outer.Inner.function();
			当内部类定义了静态成员时，该类必须是静态的
			当外部类中的静态方法访问内部类时，内部类也必须是静态的	

	定义原则：
		当描述事物时，事物的内部还有事物，该事物用内部类来描述
		因为内部事物在使用外部事物的内容
			e.g：描述人体，人体由各种器官等构成，当然可以把心脏当一个功能描述，
			但是不具体，心脏也有属性和行为，所以把心脏封装成对象；
			另人体是直接访问心脏的，在人体中new个心脏，不太合适。
			通常还回将它私有，防止任意被访问，也需要提供访问方式(例如检测维护等)
	
	总结：内部类定义在类内部，所以就有类的成员属性
		  静态内部类、成员内部类、局部内部类
		  内部类编译后的文件名为：“外部类名$内部类名.class”；

	匿名内部类	
		定义：匿名内部类就是内部类的简写格式，就是没有名字的内部类，
			  匿名内部类其实就是一个匿名子类对象。
		前提：匿名内部类必须是继承一个类或者实现一个接口，通过类型提升借助多态方式new对象
		格式：
			new 父类名||接口名(){ 定义子类成员或者覆盖父类方法; };
			new 父类名||接口名(){ 定义子类成员或者覆盖父类方法; }.方法();
	
	使用场景
		当函数的参数是接口类型引用，接口中的方法不超过3个，可通过匿名内部类来完成参数的传递。
		其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。


异常
	定义：程序运行时出现不正常情况，问题也是现实世界中一个具体的事物，
	      所以可以通过java的类形式将问题进行描述，并封装成对象
	体系：
		Throwable
			|-Error，一般不编写针对性代码对其进行处理
			|-Exception，可编写正对性代码对其进行处理
				|-RuntimeException，运行时异常
	特点：异常体系中所有类以及建立对象都具备可抛性，也就是说可以被throw和throws关键字所操作
	throw 和 throws的用法：
		throw 定义在函数内，用于抛出异常对象；
		throws 定义在函数上，用于抛出异常类，可以抛出多个，用逗号隔开
		当函数内容有throw抛出异常对象，若未进行try处理，必须要在函数上声明，否则编译失败
		注意：RuntimeException 除外，也就是如果抛出该类异常，则不需要声明
		如果声明了异常，调用者需要进行处理，处理方法可以throws或者try

	异常划分：
		1、编译时被检测异常  
			该异常在编译时如果没有处理（没有抛或者try），那么编译失败
			该异常被标识，代表可以被处理
		2、运行时异常（编译时不检测）
			在编译时，不需要处理，编译器不检查，即编译可通过
			该异常发生，建议不处理，让程序停止，需要对代码进行修正

	异常处理语句
		try
		{
			需要被检测的代码	
		}
		catch (异常对象)
		{
			异常处理代码
		}
		finally
		{
			一定会执行的代码
		}
		有三种结合的形式，另外两种，try+catch，try+finally
		对捕获到的异常对象进行常见方法操作
			getMessage    获取异常信息 /by zero
			toString	  异常名称、异常信息 /
			printStackTrace  打印堆站跟踪信息（void类型没有返回值），构造函数可以直接加IO流 /最全	
		注意：finally定义的通常是  关闭资源代码，因为资源必须释放
			  finally只有一种情况不会执行，当执行到System.exit(0),jvm结束
	
	自定义异常：
		项目中有时会出现特有的问题，这些问题并未被java所描述和封装，
		所以对于这些特有的问题可以按照java的对问题封装的思想来对特有的问题进行自定义的异常封装
		定义类继承Exception或者RuntimeException
		1、让该类具备可抛性
		2、让该类具备操作异常的共性方法
		继承Exception原因：
			异常体系有一个特点，异常类和异常对象都需被抛出
			他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点。
		当要定义自定义异常的信息时，因为父类中已经把操作异常的信息完成了，
		所以子类只要在构造时，将异常信息传递给父类通过super()语句,
		 就可以通过父类已有方法获取信息。
		class MyException extends Exception{
			MyException(String message)	{
				super(message);
			}
		}
		
	异常的好处
		1、将问题进行封装
		2、将正常流程对面和问题处理代码相分离，方便阅读

	异常的处理原则
		1、处理方式：try或者throws
		2、如果调用到抛出异常的功能时，抛出几个，就处理几个，
			所以会出现一个try对应多个catch情况
		3、声明了几个异常，就对应有几个catch块，若多个catch中异常出现了继承关系，父类的catch往下放，
		4、catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace
		也不要不写，当捕获到的异常，本功能处理不了时，可以继续在catch中抛出
		try
		{
			throw new AException();
		}
		catch (AException e)
		{
			throw e;
		}
		如果该异常处理不了，并不属于该功能出现的异常
		可以将异常转换后，在抛出和该功能相关的异常
		异常可以处理，当需要将异常长生的和本功能相关的问题提供出去
		当调用者知道，并处理，也可以将捕获异常处理后，转换新的异常
		try
		{
			throw new AException();
		}
		catch (AException e)
		{
			对A异常处理
			throw new BException();
		}
		例如A汇给B 100元，ATM划走100元，若没成功，则先做处理即返回100，然后在抛出没汇成功异常

	异常在子父类覆盖中的体现：
		1、子类在覆盖父类，如父类方法抛出异常，那么子类的该方法，只能抛出父类抛出的异常或者其子类
			若某个类中有方法接收父类型引用，调用了父类方法，且有针对的异常处理，
			这时若子类对象以多态形式被该方法执行，则会调用子类复写后的方法，
			那么若子类复写方法抛出了新异常，则原异常处理解决不了，就会编译失败。
		2、如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类的这些异常的子集，
		3、如果父类或者接口的方法中没有异常抛出，子类在覆盖方法时，也不能抛出异常
			如果子类方法发生了异常，就必要进行try处理，绝对不能抛
		总结，父类抛出异常，子类只能抛出这些异常的子集或者子类异常，如果另有异常发生，则在本方法内处理。	

包	
	定义包用package关键字。
		1、对类文件进行分类管理。
		2、给类文件提供多层名称空间。
		3、将类文件与源文件进行分离
	package pack;定义了一个包，名称为pack。 注意：包名的写法规范：所有字母都小写。
	如果生成的包不在当前目录下，需要执行classpath，将包所在父目录定义到classpath变量中即可
	
	一般在定义包名时，因为包的出现是为了区分重名的类。所以包名要尽量唯一；
		可以使用url域名来进行包名称的定义。package com.itheima.pack.demo;
		
	类的全名称是 包名.类名
		编译命令：javac –d . java源文件 （就可以自动生成包）
		-d 后加的是存储路径，写.指的是当前目录；

	包也是一种封装形式，用于封装类，想要被包以外的程序访问，该类必须public；
		类中的成员，如果被包以外访问，也必须public；
		不同包中的子类还可以直接访问父类中被protected权限修饰的成员；
		一个.java文件只能有一个public类，且文件名与该类名必须一致；

	包与包之间访问可以使用的权限：
		1、public	 2、protected

	总结java中的四种权限：
		范围       public		protected		default		private 
	同一个类中          ok			    ok		          ok		  ok
	同一包中            ok			    ok		  	  ok		
	不同包子类	    ok			    ok
	不同包中            ok

	Import导入：为了简化类名的书写，使用import关键字，将指定包中的类导入。
		记住：实际开发时,到的哪个类就导入哪个类，不建议使用*.
	import packa.*; 这个仅仅是导入了packa当前目录下的所有的类。不包含子包。
	如果导入的两个包中存在着相同名称的类。这时如果用到该类，必须在代码中指定包名。

	常见的软件包:
	java.lang : language java的核心包，
				Object System  String Throwable jdk1.2版本后，该包中的类自动被导入。
	java.awt : 定义的都是用于java图形界面开发的对象。
	javax.swing: 提供所有的windows桌面应用程序包括的控件,
				比如：Frame , Dialog, Table, List 等等,就是java的图形界面库。
	java.net : 用于java网络编程方面的对象都在该包中。
	java.io : input  output 用于操作设备上数据的对象都在该包中。
	java.util : java的工具包，时间对象，集合框架。
	java.applet: application+let 客户端java小程序。server+let-->servlet 服务端java小程序。
	jar ：java的压缩包，主要用于存储类文件，或者配置文件等。
		命令格式：jar –cf 包名.jar 包目录
	        解压缩：jar –xvf 包名.jar 
		将jar包目录列表重定向到一个文件中：jar –tf 包名.jar >c:\1.txt




 
 

  
  ------------- 
  
  android培训、
  
  java培训、java博客、java学习型技术博客、期待与您交流！ -------------
  
  

 
 
 
 

  
  详情请查看：http://edu.csdn.net/heima/