Java_Day05学习

Object类被子类经常重写的方法

Object类

Object类的 equals() 方法
比较两个对象是否是同一个对象，是则返回true
    
    
instanceof
	用于判断一个引用类型所引用的对象是否是一个类的实例
	可以用 instanceof 判断一个类是否实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。instanceof 的语法格式为:
	eg:
	if (a instanceof Cat) { // 猫做的事情
            Cat c = (Cat) a;
            c.work();
    对象 instanceof 类(或接口)
它的返回值是布尔型的，或真(true)、或假(false)。

多态

定义：多态就是指一个类实例的相同方法在不同情形有不同表现形式。
    //同一个引用类型，使用不同的实例而执行不同操作
	eg:
            //父类的声明   对象   =    new     子类的对象;
            Person_homework test = new China_People();
            //父类和子类中都存在的方法 最终执行的是子类的方法
            test.work();

优点：
	//频繁修改代码，代码可扩展性、可维护性差
    

多态就是同一个接口，使用不同的实例而执行不同操作
     
多态的三个条件:
    继承的存在(继承是多态的基础，没有继承就没有多态)；
    子类重写父类的方法(多态下调用子类重写的方法)；
    父类引用变量指向子类对象(子类到父类的类型转换)。
    
子类转换成父类时的规则:
    将一个父类的引用指向一个子类的对象，称为向上转型(upcasting)，自动进行类型转换。
    
    
        
        
        
        
        
  总结：
一、多态
1、定义：
	1）生活中：同一事物，在不同环境下，表现出不同的形态
	2）程序中：同一引用类型，传入不同的实例，会得到不同结果
2、多态的实现步骤：
	1）子类继承父类
	2）子类重写父类的方法
	3）父类引用，传入子类实例
3、多态的两种表现形式
	1）父类作为方法的参数出现
	2）父类作为方法的返回值出现
4、引用类型之间转换
	1）向上转型：直接转，即  父类  父对象=new 子类();
	2）向下转型：强制转，即  子类  子对象=(父类)父对象;强制转换易引发ClassCastException，因此转换之前需判断类型是否匹配
		if(obj instanceof 类)则进行转换
	3）原因：子  is  a  父；  父 has 子
5、多态的优点：提高代码的可扩展性
6、父类引用指向子类实例的注意事项
	1）父类引用指向父类实例：父类 父对象=new 父类();可访问父类的允许访问成员
	2）子类引用指向子类实例：子类 子对象=new 子类();可访问父类和子类的允许访问成员
	3）父类引用指向子类实例：父类 父对象=new 子类();可以访问父类允许访问的成员；不允许访问子类特有成员；但如果子类重写了父类方法，则调用的是子类重写后的方法
	
    
    
    
    
    
    

多态的例子

                        public class TestAnimalDemo {
                            public static void main(String[] args) {
                                // 向上转型
                                Animal a = new Cat(); 
                                a.eat(); // 调用的是 Cat 的 eat
                                
                                
                                
                                show(new Cat()); // 以 Cat 对象调用 show 方法
                                show(new Dog()); // 以 Dog 对象调用 show 方法
                                Cat c = (Cat) a; // 向下转型
                                c.work(); // 调用的是 Cat 的 work
                            }
                            /**
                            *
                            */
                            public static void show(Animal a) {
                                a.eat();
                                // 类型判断
                                if (a instanceof Cat) { // 猫做的事情
                                    Cat c = (Cat) a;
                                    c.work();
                                } else if (a instanceof Dog) { // 狗做的事情
                                    Dog c = (Dog) a;
                                    c.work();
                                }
                            }
                        }
                        abstract class Animal {
                            abstract void eat();
                        }
                        class Cat extends Animal {
                            public void eat() {
                                System.out.println("吃鱼");
                            }
                            public void work() {
                                System.out.println("抓老鼠");
                            }
                        }
                        class Dog extends Animal {
                            public void eat() {
                                System.out.println("吃骨头");
                            }
                            public void work() {
                                System.out.println("看家");
                            }
                        }


输出：
    

                    吃鱼
                    抓老鼠
                    吃骨头
                    看家
                    吃鱼
                    抓老鼠

抽象类

1.定义：Java也可以创建一种类专门用来当作父类，这种类称为“抽象类”；
//抽象类的作用有点类似“模版”，其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。
    eg:
	abstract class 类名称 // 定义抽象类
{
    声明数据成员;
    
    访问权限 返回值的数据类型 方法名称（参数...）//定义一般方法
    {
        ...
    }
    
    abstract 返回值的数据类型 方法名称（参数...）;
    //定义抽象方法，在抽象方法里，没有定义方法体
}
//但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例
//普通类可以被实例化

2.规则：
    //抽象类和抽象方法都必须用abstract关键字来修饰；
    //抽象类不能被实例化，也就是不能用new关键字去产生对象；
    //抽象方法只需声明，而不需实现；
    //含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才		能被实例化，否则这个子类还是个抽象类。


2.抽象方法VS普通方法
有无方法体
    
    
    
3.抽象类与抽象方法的使用
    //抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
    //如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
    //没有抽象构造方法，也没有抽象静态方法
    //抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
    
    
    
    

接口

public interfaceMyInterface {public void foo()；//其他方法}

1.接口的特性
	//接口不可以被实例化
	//实现类必须实现接口的所有方法
    //实现类可以实现多个接口 implements、多个接口使用逗号隔开
    //接口中的变量都是静态常量（public static final）
2.面向接口编程
    程序设计时：
    	关心实现类有何能力，而不关心实现细节
    	面向接口的约定而不考虑接口的具体实现

异常

1.定义：
	异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序
2.Java的异常处理的5个关键字：try、catch、finally、throw、throws
	try() :执行可能产生异常的代码,放到这个模块
	catch() 发生异常时，捕获异常，丢给E
	finally() 无论是否发生异常，代码总能执行
	throw()手动抛出异常
	throws()抛出的各种异常声明方法可能要抛出各种异常
        

printStackTrace()的堆栈跟踪功能显示出程序运行到当前类的执行流程
        可以打印出异常堆栈信息
        //异常类型 InputMismatchException
         java.util.InputMismatchException
        //哪一个方法（main）中抛出了异常，出现异常的位置 Test3.java:15
         at cn.jbit.exception.Test3.main(Test3.java:15)
getMessage()返回异常信息描述字符串，是printStackTrace()输出信息的一部分
        
        
eg:
package com.dx.test04;
import java.util.Scanner;
public class Java01 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int a = input.nextInt();
        if (a > 10) {
            try {
                //1、将所有的可能出现的异常代码放到try
                System.out.println("创建流对象"); //出现异常前的都会被执行并输出
                System.out.println(10 / 0);
                System.out.println("写文件");
            } catch (Exception e) {    //若 catch (异常类型ex)  异常类型不匹配，程序中断
                // 2捕捉异常 ->异常处理(只有出现异常了，才会执行catch)
                 e.printStackTrace();     //打印出现的异常情况
                System.out.println("出现异常啦.....");
                return XXX; //如果有return 要先执行finally 再返回catch执行return
            } finally {
                //不管有异常还是没有异常，finally代码一定会被执行
                //唯一不执行的情况，catch没抓到异常 ，直接报错，中断程序了，退出Java虚拟机
                 System.out.println("释放流");
            }
        }else{
            System.out.println("我也不知道干啥...");
        }
        System.out.println("不能影响我去玩....");
    }
}
打印结果：
    
    创建流对象
    出现异常啦.....
    释放流
    不能影响我去玩....
    java.lang.ArithmeticException: / by zero
        at com.dx.test04.Java01.main(Java01.java:11)

多重catch块

//引发多种类型的异常
   排列catch语句的顺序：
    	先子类后父类
    	发生异常时按顺序逐个匹配
		只执行第一个与异常类型匹配的catch语句
    
    
tips：
    //try-catch-finally结构中try语句块是必须的，catch、finally语句块均可选，但两者至少出现之一
	//try-catch块中存在return语句，是否还执行finally块? 如果执行，说出执行顺序
    //try-catch-finally块中，finally块唯一不执行的情况是什么？

声明异常

throw 自动抛出异常
public void myMethod() throw IOException, SQLException {
    // 方法体
}
    
throws 手动抛出异常
public void myMethod() throws IOException, SQLException {
    // 方法体
}
    
如果在一个方法体中抛出了异常，如何通知调用者？
	throws声明某个方法可能抛出的各种异常，多个异常用逗号隔开
//方式1：调用者处理异常
//方式2：调用者继续声明异常 ⚫main()方法声明的异常由Java虚拟机处理
    
    
throw与throws区别

//如果一个值为null，不能.属性和方法，一旦.就抛出空指针异常