黑马程序员--java基础--多态，内部类，异常等

------- android培训、 java培训、期待与您交流！ ---------

多态：

允许不同类的对象对同一消息作出响应

1.多态的体现

父类的引用指向自己的子类对象

父类的引用也可以接受自己的子类对象

2.多态的前提

类和类之间有关系。继承。实现。

存在覆盖。

3.多态的好处

提高程序的扩展性

例子：

package com.itheima;

abstract class Animal{
	public void eat(){
		};
}
class Dog extends Animal{
	public void eat(){
		System.out.println("吃骨头");
	};
	public void kanjia(){
		System.out.println("看家");
	}
}
class Pig extends Animal{
	public void eat(){
		System.out.println("稻谷");
	};
	public void sleep(){
		System.out.println("睡觉");
	};
}
public class Natural {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		function(new Dog());
		function(new Pig());
		
		Animal a = new Dog();
		//向上转型
		a.eat();
		//吃骨头
		Dog d = (Dog)a;
		//当知道是什么类型的时候可以向下转型，不然不对
		d.kanjia();
	}
	public static void function(Animal a)  
    {  
        a.eat();  
        //用于子类型有限  
        //或判断所属类型进而使用其特有方法  
       if(a instanceof Pig){
    	   	Pig p = (Pig)a;
    	   	p.sleep();
       }else if(a instanceof Dog){
    		Dog d = (Dog)a;
    	   	d.kanjia();
       }
    }  
}

内部类：将一个类定义到另一个类中。

访问特点：

内部类可以直接访问外部类的所有属性和方法，而外部类必须实例化内部类

内部类可分为：

1.成员内部类

2.局部内部类

3.静态内部类

4.匿名内部类

1.成员内部类

作为外部类的成员存在，与外部类的属性方法并列。

package com.itheima;

import com.itheima.out.Inner1;


public class OutTest {

	/**
	 * @param args
	 */

	public static void main(String[] args) {
		// 直接访问外部类中的内部类中的成员。 
		out.Inner1 in1= new out().new Inner1();
		in1.method_2();
		//如果内部类是静态的。 相当于一个外部类 
//		out.Inner2 in2 = new out.Inner2();
//		in2.method_3();
//		//如果内部类是静态的，成员是静态的。
//		out.Inner2.method_4();
	}
}
class out{
	
	public String color = "pink";
	private String name = "out";
	public int num1 = 2;
	//外部类的非静态方法访问成员内部类
	public void method_1(){
		Inner1 inner1 = new Inner1();
		inner1.method_2();
	}
	//外部类的静态方法访问成员内部类
	public static void method_3(){
		out.Inner1 inner1 = new out().new Inner1();
		inner1.method_2();
	}

	class Inner1{
		public int num1 = 1;
		public void method_2(){
			System.out.println("method_2");
			System.out.println(out.this.num1);
			 //在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
			System.out.println(this.num1 + "or"  +num1);
			 //在内部类中访问内部类自己的变量也可以用this.变量名
			System.out.println(num1);
		}
	}
	
//	static class Inner2{
//		public int num1 = 3;
//		public void method_3(){
//			System.out.println("method_3");
//			
//		}
//		public static void method_4(){
//			System.out.println("method_4");
//			
//		}
}
	

2.局部内部类

在方法中定义的内部类。

package com.itheima;


public class OutTest {

	/**
	 * @param args
	 */

	public static void main(String[] args) {
		out out = new out();
		out.method_1();
	}
}
class out{
	
	public String color = "pink";
	private String name = "out";
	public int num1 = 2;
	//定义在外部类的方法内
	public void method_1(){
			class Inner1{
				Inner1(){};
				public String color = "black";
				public int age = 20;
				void show_1(){
					//如果变量名相同，访问的是内部类的变量
					System.out.println(color);
					//在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
					System.out.println(out.this.color);
				}
			}
			new Inner1().show_1();
	}
	
}


	

	

3.静态内部类

package com.itheima;

import com.itheima.out.inner;


public class OutTest {

	/**
	 * @param args
	 */

	public static void main(String[] args) {
		//生成静态内部类
		out.inner test = new out.inner();
		test.show();
	}
}
class out{
	
	public String color = "pink";
	private String name = "out";
	public int num1 = 1;
	//定义在外部类的方法内
	public void method_1(){
			System.out.println("method_1");
	}
	static class inner{
		public String color = "white";
		private String name = "in";
		public int num2 = 2;
		void show(){
			//只能访问外部类中的私有变量
			System.out.println(name);
			System.out.println(color);
		}
	}
}


	

	

4.匿名内部类

在只使用到一次该类的实例时可以使用

package com.itheima;



abstract class Person {
    public abstract void eat();
}
 
public class OutTest {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

在外部先申明，再在创建内部类的同时实现方法并调用。

异常：

一、 异常的概念,什么是异常？


Throwable
        |-->Error
        |-->Eeception
                |-->RuntimeEeception

异常的好处：

1.将问题进行封装

2.将正常代码和问题代码分离，方便阅读

异常是程序运行中或编译时出现的错误。
分为:
1.编译时异常
Java.lang.Exception
2.运行时异常
Java.lang.RuntimeException


Error是程序无法处理的错误
对于Error一般不编写针对性的代码对其进行处理


编译时异常：
Java编译器强制要求处理编译时异常，如果不捕获这类异常，程序将不能被编译，也就无法运行。
该异常在编译时，如果没有处理，编译失败异常被标示，代表可以被处理。
运行时异常（编译时不检测）：
译器不强制要求处理编译时异常，发现这异常的时候，没有去处理这个异常，是会中断程序的运行。
如角标越界
在编译时，不需要处理，编译器不检查。
                该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

涉及到的关键字：try、catch、finally、throw、throws。


编译时异常的处理方式：
1.抛出异常  throws Exception
2.try/catch异常
一般情况下使用try/catch异常，直接抛出异常给调用层不太负责，

二、 try/catch异常

1.try/catch异常

 <span style="white-space:pre">	</span>try
        {
               //（尝试运行的）程序代码  
        }
        catch（异常类型 异常的变量名）
        {
              // 异常处理代码 
        }

2.try/catch/finally异常

 	try
        {
               //（尝试运行的）程序代码  
        }
        catch（异常类型 异常的变量名）
        {
              // 异常处理代码 
        }
        fianlly
        {
              //异常发生，方法返回之前，一定会执行的代码 
	      //一般为关闭资源
        }

3.try/finally异常

 	try
        {
               //（尝试运行的）程序代码  
        }
        fianlly
        {
              //异常发生，方法返回之前，一定会执行的代码 
	      //一般为关闭资源
        }

finally语句是一定要执行的语句，除非System.exit（0）退出虚拟机

三：throw、throws关键字
throw关键字是用于方法体内部，用来抛出一个Throwable类型的异常。


throws关键字用于方法的声明，用来声明方法可能会抛出某些异常。
仅当抛出了检查异常，该方法的调用者才必须处理或者重新抛出该异常。



四:自定义异常类
        定义类继承Eeception或者RuntimeEeception
        1，为了让该自定义类具备可抛性，
        2，让该类具备异常方法处理的，
        
自定义异常，按照java的面向对象思想，将程序中出现的特有问题进行封装
throw  单独存在，下面不要定义语句

-------- android培训、java培训、期待与您交流！ ----------