黑马程序员--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培训、期待与您交流！ ----------

秒客网

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

相关文章