java学习笔记--面向对象部分

接口定义时，格式的特点：
1，接口中常见的定义：常量，抽象方法
常量：public static final
方法：public abstract
接口中的成员都是public的

public interface Inter {
	public static final int X_NUM=3;//全局常量啊 必须大写
	public abstract void show();
}

接口：不可以创建对象，因为有抽象方法 需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化，否则，子类
是一个抽象类

接口中的静态常量 可以通过三种方式来调用
注意：接口中的常量是不可赋值的 常量 当然不可以赋值了
接口支持多继承，类支持多实现

public static void main(String[] args) {
		InterFaceTest it=new InterFaceTest();
		System.out.println("对象中"+it.X_NUM);
		System.out.println("实现类中"+InterFaceTest.X_NUM);
		System.out.println("接口中"+Inter.X_NUM);
	}

==================================================================================

Polymorphic
1.多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象
2.多态的前提
必须是类与类之间有关系，要么继承，要么实现
通常还有一个前提：存在覆盖
3.多态的好处
多态性的出现大大的提高了程序的扩展性
4.多态的应用

5.多态性的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员

6.多态的出现代码中的特点（多态使用的注意事项）
a.在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有则编译通过 如果没有 则编译失败
在运行时期：参阅对象所属的类中是否有调用的方法
简单总结为：成员函数在多态调用时，编译看左边，运行看右边
b.在多态中,成员变量的特点:
无论编译和运行，都参考左边（引用型变量所属的类）
c.无论编译或着运行中，都参考左边
==================================================================================
Object类中的方法 override equeal方法
equal方法平常理解为比较对象的值是否相等 但是在Object类中 其实现是这样的
public boolean equals(Object obj) { return (this == obj);//证明.内部用的就是==符号 }
而==是比较的地址值
通常会在类中override equal方法 例如下面 复写equals方法 比较ObjectSon类中的num值 如果相等 则返回true

public class ObjectSon {
	int num;
	public ObjectSon(int num)
	{this.num=num;}
	public boolean equals(Object obj) {
		if(!(obj instanceof ObjectSon))
		{	System.out.println("类型不匹配");
			return false;
			}
		else {
			ObjectSon os=(ObjectSon)obj;
			boolean b = false;
			if(this.num==os.num){
				b=true;
				System.out.println("相等哦 亲");
				System.out.println("this.num="+this.num+"  "+"os.num="+os.num);
			}else {
				b=false;
				System.out.println("this.num="+this.num+"  "+"os.num="+os.num);	
				System.out.println("不相等");
					}
		return b;
		}
	}		
}

测试程序如下

public class ObjectDemo {
	public static void main(String[] args) {

		ObjectSon os1=new ObjectSon(1);
		ObjectSon 	os2=new ObjectSon(2);
		os1.equals(os2);
	}
}
输出结果如下：this.num=1  os.num=2
			   不相等  

==================================================================================
内部类：
内部类的访问规则：
1.内部类可以直接访问外部类的成员，包括私有
2.外部类要访问内部类，则必须要建立内部类对象。
实例代码如下

public class Outer {//外部类
	private int num=3;//外部类私有成员
	public void visit_Inter()//外部类访问内部类的方法
	{
		Inter in=new Inter();//外部类访问内部类需要建立内部类对象
		in.haha();//调用内部类方法
	}
	Outer(int n)//外部类构造函数
	{
		this.num=num;
	}
	class Inter//在外部类的类体中声明内部类
	{	private int num=4;//内部类私有成员
		public void visitOuter()//内部类访问---外部类方法
		{
			int num=5;
			System.out.println("外部类的成员num的值为"+Outer.this.num);//如果有重名，加外部类.this.成员
			System.out.println("内部类的成员num的值为"+this.num);
			System.out.println("方法visitOuter中的num值为"+num);
		}
		public void haha(){
			System.out.println("haha");
			visitOuter();
		}
	}
}
public class InterClassDemo {//测试程序
	public static void main(String[] args) {
		Outer ou=new Outer(1);
		ou.visit_Inter();
		Outer.Inter oi=new Outer(1).new Inter();//想要直接访问内部类必须这样做
		//首先生产内部类对象
	}
}

==================================================================================
静态内部类
static:内部类就具备static的特性
当内部类被static修饰时，只能出现外部类中的static成员，出现了访问局限
在外部其他类中如何访问static内部类？
new Outer.Inter().visitOuter();//直接用类名就可以调用static内部类中的方法
注意：当内部类中定义了静态成员，该内部类必须是static的
当外部类中的静态方法访问内部类时，内部类也必须是static的



==================================================================================
当描述事物时，事物的内部还有事物，该事物用内部类来描述。
因为内部事物在使用外部事物的内容。

class Body{
	private class heart{
	}
	public void show(){
		new heart().
	}
} 

==================================================================================
内部类定义在局部时：
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员,因为还持有外部类中的引用，
但是不可以访问它所在的局部中的变量 。只能访问被final修饰的局部变量
示例如下：

public class Outer {
	int x=3;
	void method(final int a)
	{
		final int y=4;//从内部类中访问局部变量y,需要被声明为最终类型	
		class Inner
		{//局部内部类 不可以用static修饰，注意static是成员修饰符  
			void function()
			{
				System.out.println(Outer.this.x);
				System.out.println(y);
				System.out.println(a);
			}
		}
		new Inner().function();//调用内部类中的方法需要先生成内部类对象再调用
	}
}
//Test代码如下：
public class InnerClassDemo {
	public static void main(String[] args) {
		Outer ou=new Outer();
		ou.method(1);
		ou.method(2);
	}
} 
//输出结果如下：341342

==================================================================================
匿名内部类：
1.匿名内部类其实就是内部类的简写格式。
2.定义匿名内部类的前提：内部类必须是继承一个类或者是是实现接口
3.匿名内部类的格式： new父类或者接口(){定义子类的内容}.方法；
4.其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，也可以理解为带内容的对象
示例如下：

public abstract class AbsDemo {//首先需要有一个父类或者接口以提供匿名内部类继承
	abstract void show();
}

public class Outer {//内部类在这里实现
	int x=3;
	/*class Inner extends AbsDemo
	{
		void show() 
		{
			System.out.println("这是从AbsDemo继承的show方法");	
		}		
	}*///这是之前的写法
	void function()
	{
		//new Inner().show();
		new AbsDemo() {		
			void show() {
				System.out.println("这是从AbsDemo继承的show方法");					
			}
		}.show();//这是AbsDemo的匿名子类对象再调用show方法
	}
}

=================================================================================
匿名内部类的小练习
补全代码，要求用内部类实现 Test代码如下

public class GuiTest {
	public static void main(String[] args) {
		GUI.function().close();
	}
}

分析 GUI大写 为类 GUI.function()推出function()为静态方法 可以由GUI类直接调用。而GUI.function().close()说明funcion()
返回的是一个对象 这个对象再调用close方法 所以首先写出接口

public interface Close {
	abstract void close();
}//供内部类去实现
外部类如下
public class GUI {
	static Close function()//方法为静态 可以被类名直接调用 而且返回的是接口类型 多态的体现 父类引用指向子类对象
	{
		return new Close() {	//其实返回的就是个对象 这里是实现接口Close的一个对象		
			public void close() {//实现接口中的方法
				System.out.println("GUI中内部类调用close方法 关闭");				
			}
		};//这里别忘记用分号结束
	}
}

=================================================================================
异常：就是在程序运行期间（注意是运行时）出现的不正常情况
异常的由来:问题也是现实生活中的具体的事物，也可以通过Java的类的形式进行描述，并且封装成对象。
其实就是Java对不正常情况进行描述后的对象体现。
对于问题的划分 分为两种 1.严重的问题 -->java通过Error类进行描述（艾滋不可治疗）
对于Error一般不编写针对性的代码对其进行处理
2.非严重的问题-->java通过Exception进行描述（咳嗽，随意了）
对于Exception可以使用针对性的处理方式进行处理
Java提供了特有的语句对异常进行处理
try
{
需要被检测的代码
}
catch(异常类型 变量)
{
处理异常的代码：（处理方式）
}
finally
{
一定会被执行的语句
}
//记住一点：catch是处理异常的。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明
==================================================================================
异常在子父类覆盖中的体现;
1.子类在覆盖父类时，如果父类方法抛出了异常，那么子类覆盖的方法，只能抛出父类的异常或者该子类的异常
2.如果父类方法抛出多个异常，那么继承自父类的子类只能抛出父类异常的子集以及子类
3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常
如果子类方法发生了异常。就必须要进行try处理。绝对不能抛出

实例如下：

public class AException extends Exception{}//声明父类异常AException
 public class B_Exception extends AException{}//声明子类异常继承A异常
 public class Fu {//父类方法 抛出A异常
	public void show() throws AException
	{	
	}
}
	public class Zi extends Fu{//子类继承自Fu类
	public void show() throws AException,B_Exception//Zi类只可以抛出所继承的父类的异常或者是子异常
	{		
	}	
}

==================================================================================

异常的总结：
异常是对问题的描述。将问题进行对象的封装
异常体系：
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系的特点：异常体系中所有的类以及建立的对象都具备可抛性。
也就是说可以被throw和throws关键字操作
也只有异常体系具备这个特点
throw和throws的用法：
throw定义在函数体内部，用于抛出对象
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开

当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败
注意，RuntimeException除外。也就是说，函数内如果抛出的是RuntimeException异常,函数上可以不用声明
如果函数声明了异常，调用者需要进行处理。处理方法可以throws 可以try

异常有两种：
1.编译时被检测异常
该异常在编译时，如果没有处理（没有抛出，也没有try） ,则编译失败
该异常被标识，代表这可以被处理

2. 运行时异常（编译时不检测）
在编译时，不需要处理，编译器不检查
该异常的发生，建议不处理，让程序停止。需要对代码进行修正
需要注意的是：finally一般用来关闭资源
但是有一种情况不执行 就是在catch语句中这么写
try{}
catch(){System.exit(0)//退出JVM}
自定义异常：
定义类继承Exception或者RuntimeException
1，为了让该自定义类具有可抛出性2，让该类具备操作异常的共性方法
当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
异常的异常信息传递给父类的构造函数。
class MyException extends Exception（Strring msg）
{
super(msg);//调用父类的构造方法
}

自定义异常：按照Java的面向对象的思想，将程序 中出现的特有问题进行封装
异常的好处：1，将问题进行封装
2，将正常流程代码和问题处理代码相分离，方便于阅读

异常的处理原则：
1，处理方式有2种 ：try 或者throws
2,调用到抛出异常功能时, 抛出几个处理几个。一个try对应多个catch
3，多个catch,父类的catch放到最下面
4，catch内需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。也不要不写
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出
try{
throw new A_Exception()
}cathc(A_Exception e){
throw e
}
//如果该异常处理不了，但并不属于该功能出现的异常 可以将该异常转换后，再抛出和该功能相关的异常
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道并处理，也可以将捕获异常处理后，转换新的异常抛出
try{
throw new A_Exception();
}catch(A_Exception e){
//对A_Exception处理
throw new B_Exception();
}

异常的注意事项：
1.在子类抛出的抛出的异常必须是父类的异常的子类或者子集
2.如果父类或者接口没有异常抛出时，子类覆盖的方法中出现异常时，只能try 不可以抛出异常