2.10 小结练习（多线程之前）

1.多态，向上转型，方法，编译看左，运行看右（动态绑定）

2.多态，向上转型，方法，编译看左，运行看右（动态绑定）

3.多态，向上转型，方法，编译看左，运行看右（动态绑定）

4.多态，向上转型，变量，都看左

5.匿名内部类

6.非静态的内部类中不能定义静态成员

7.覆盖，覆盖方法权限要大于被覆盖的，参数列表和返回值类型都要相同，参数列表不同就是子类特有方法。返回值类型不同，就会出错，因为调用不确定性。

8.

this:
代表当前对象，就是所在函数所属对象的引用。

final:
1.final可以修饰类，方法，变量
2.final修饰的类不可以继承
3.final修饰的方法不可以被覆盖
4.final修饰的变量是一个常量，只能赋值一次。
  ①使用final和直接使用9区别在于，可以取常量名，加强阅读性。
  ②final只固定变量的显示初始化值，所以必须显示赋值。
  ③一般都会加静态static。如果再加public：
public static final int x = 4;   这称为全局常量。

9.多态

10.接口的实现

11.异常：捕捉

12.对象的初始化过程

13.覆盖

14.抛出异常语句下不能有任何语句存在。

15.非静态的内部类在主函数中无法创建对象，声明成静态后，可以通过外部类调用new Demo.Inner();
或者new Demo().new Inner();

16.异常捕捉多catch问题

17.匿名内部类

18.异常：捕捉

19.单或和双或的区别：

20.接口：定义额外的功能

/*
练习一：

                建立一个图形接口，声明一个面积函数，图形和矩形都实现这个接口，并得出两个图形的面积。
                注：体现面向对象的特征，对数值进行判断。用异常处理。不合法的数值要出现 “ 这个数值是非法的 ”提示，不再进行运算。

*/


interface Areable      //图形面积计算接口
{
    public static final double PI = 3.14; 
    public abstract double getArea();       //面积计算函数
}




class outOfAreaException extends RuntimeException   //数值非法异常类
{
        outOfAreaException()
        {

        }
        outOfAreaException(String msg)
        {
            super(msg);
        }
}




class Circular implements Graph        //圆形类
{
    private double r;         //圆半径

    Circular(double r)
    {
        if(r<0)
            throw new outOfAreaException("这个数值是非法的");  //当半径小于0，抛出数值非法异常
        this.r = r;
    }

    public double getArea()          //实现接口的抽象方法
    {
            return PI*Math.pow(r,2);
    }
}




class Rec implements Graph       //矩形类
{
    private double length,width;               //定义长宽，顺序无所谓

    Rec(double length, double width)
    {
        if( length<0 ||  width<0)
                throw new outOfAreaException("这个数值是非法的");  //当半径小于0，抛出数值非法异常
            this.length =length;
            this.width =width;
    }

    public double getArea()       //实现接口的抽象方法
    {           
                return length*width;
    }
}




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

         Graph g =  new Circular(-5.6);   //初始化时如果数据存在负值，会抛出数值非法异常

        double area = g.getArea();  
        System.out.println(g.getClass().getName() + "'s area is " +area);   

    }

}

1. 继承

/*
        练习二：
                        假如我们在开发一个系统时需要对员工进行建模，员工包含3个属性：姓名，工号，工资。
                        经理也是员工，除了含有员工的属性外，还有奖金属性。
                        请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

*/

class Employee    //员工类
{
    private String name,eNum;
    private int wages;
    Employee(String name,String eNum, int wages)
    {
        this.name = name;
        this.eNum = eNum;
        this.wages = wages;
    }

    void print()
    {
        System.out.print(name + "的工号是："  + eNum + ", 每月工资：" + wages + "元。");
    }

}

class Manager extends Employee  //经理类 
{
         private int bonus;
        Manager(String name,String eNum, int wages, int bonus)
        {
            super(name,eNum,wages);
            this.bonus = bonus;
        }
        void print()
    {
            System.out.println();
            super.print();          
            System.out.print("奖金：" + bonus + "元。");

    }
}



class Practice2 
{
    public static void main(String[] args) 
    {
        Employee e = new Employee("张三","20143921005",8000);
        e.print();
        Manager m = new Manager("刘勇","20092013004",12000,6000);
        m.print();
    }
}

1. 异常抛出：运行时异常 不需要声明

/*
        在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在数组中第一次出现的
        位置（序号从0开始计算），否者，返回-1。
        要搜索的字符数组和字符都以参数形式传递给该方法，如果传入的数组是null，应抛出IllegalArgumentException不合法参数异常。
        在类的main方法中以各种可能出现的情况测试验证该方法编写的是否正确。例如：
        字符不存在，字符存在，传入的数组为null。
*/

class ArrLookup
{
     int getIndex(char[] arr, char key)
    {
         if(arr == null)
                throw new IllegalArgumentException("不合法参数异常");
        for (int i = 0;i < arr.length;i++ )
        {
                if(arr[i] == key)
                    return i;
        }
        return -1;
     }
}


class Practice3 
{
    public static void main(String[] args) 
    {
        char[] arr = {'c','h','e','n','z','h','o','n','g','q','i','a','n'};
        ArrLookup a = new ArrLookup();

        System.out.println(a.getIndex(null,'a'));
    }
}