黑马程序员——java基础知识之面向对象（三）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
（一）、接口
1、什么是接口？
接口：初期理解，可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。用interface关键字来定义接口。

2、接口的格式特点
接口定义时，格式特点：
①接口中常见定义：常量，抽象方法。
②接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。

注意：
①接口是不可以创建对象的，因为有抽象方法。
②需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
③接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
④实现多个接口时，接口中不可以有返回不同类型的同名抽象函数。这样子类实现时将不能复写。

接口特点举例：

//定义抽象的学生类abstract class Student{    //都有学习的功能而且学的东西不一样    abstract void study();    //都有相同的睡觉功能    void sleep()    {        System.out.println("sleep");    }}//扩展的抽烟功能interface Smoking{    void smoke();}//ZhangSan具有学生的功能，而且扩展了抽烟的功能class ZhangSan extends Student implements Smoking{    void study(){}    public void smoke(){}}

（二）、多态
1、什么是多态？
可以理解为事物存在的多种体现形态。

2、多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。

3、多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。

4、多态的好处
多态的出现大大的提高程序的扩展性。

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

6、多态的应用

7、多态的出现代码中的特点(多态使用的注意事项)

注意：
①如果此时父类的引用想要调用Cat中特有的方法，就需要强制将父类的引用，转成子类类型，向下转型。如：Cat c = (Cat)a;
②如果父类可以创建对象，如：Animal a = new Animal(); 此时，就不能向下转型了，Cat c = (Cat)a; 这样的代码就变得不容许，编译时会报错。所以千万不能出现这样的操作，就是将父类对象转成子类类型

例子：bstract class Animal{    abstract void eat();}//猫继承动物，重写了eat的方法，并定义了自己的catchMouse方法class Cat extends Animal{    public void eat()    {        System.out.println("吃鱼");    }    public void catchMouse()    {        System.out.println("抓老鼠");    }}//狗继承动物，重写了eat的方法，并定义了自己的kanJia方法class Dog extends Animal{    public void eat()    {        System.out.println("吃骨头");    }    public void kanJia()    {        System.out.println("看家");    }}class DuoTaiDemo {    public static void main(String[] args)     {           function(new Cat());        function(new Dog());        function(new Pig());    }    //多态的利用    public static void function(Animal a)    {        a.eat();}

注意：instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)

8、在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：
无论编译和运行，都参考做左边。

9、 多态的应用
在接口中的应用,例子程序

需求：数据库的操作。数据是：用户信息。1，连接数据库。JDBC  Hibernate2，操作数据库。    c create r read  u update  d delete3，关闭数据库连接。*/interface UserInfoDao{    public void add(User user);    public void delete(User user);}class UserInfoByJDBC implements UserInofDao{    public void add(User user)    {        1,JDBC连接数据库。;        2，使用sql添加语句添加数据。;        3，关闭连接。    }    public void delete(User user)    {        1,JDBC连接数据库。;        2，使用sql添加语句删除数据。;        3，关闭连接。    }}class UserInfoByHibernate implements UserInfoDao{    public void add(User user)    {        1,Hibernate连接数据库。;        2，使用sql添加语句添加数据。;        3，关闭连接。    }    public void delete(User user)    {        1,Hibernate连接数据库。;        2，使用sql添加语句删除数据。;        3，关闭连接。    }}//定义主程序class  DBOperate{    public static void main(String[] args)     {        //UserInfoByJDBC ui = new UserInfoByJDBC();//      UserInfoByHibernate ui = new UserInfoByHibernate();        UserInfoDao ui = new UserInfoByHibernate();        ui.add(user);        ui.delete(user);    }}

10、Object类的equals方法
Object类中已经提供了对对象是否相同的比较方法。（比较的是对象的地址是否相等）
如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有比较内容即可，这就是覆盖。

class Demo //extends Object{    private int num;    Demo(int num)    {        this.num = num;    }    //覆盖父类的equals方法，比较的对象的内容是否相同    public boolean equals(Object obj)//Object obj = new Demo();    {        if(!(obj instanceof Demo))            return false;        Demo d = (Demo)obj;        return this.num == d.num;    }

11、Object类中的toString方法
父类定义的是地址，子类一般是要复写父类的toString方法，把自己的内容转换成字符串。

（三）、内部类
1、什么是内部类？
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Test1.class。编译器将会把内部类翻译成用（美元符号）分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。

2、内部类的规则和特点
①内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式： 外部类名.this。
②外部类要访问内部类，必须建立内部类对象。

3、内部类的调用格式
①当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
格式：
外部类名.内部类名 变量名 =外部类对象.内部类对象；
如： Outer.Inner in =new Outer().new Inner();
②当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：private：将内部类在外部类中进行封装。
比如：static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
③在外部其他类中，直接访问static内部类的非静态成员的格式为：
new 外部类名.内部类名（）.方法名（）；
④在外部其他类中，直接访问static内部类的静态成员格式为：
外部类名.内部类名.方法名（）；
如：Outer.Inner.function();

3/1注意：
内部类定义在局部时，
不可以被成员修饰符修饰
可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

3/2 匿名内部类
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
例子程序：

interface Inter{    void method();}class Test {    //补足代码。通过匿名内部类。    /*    static class Inner implements Inter    {        public void method()        {            System.out.println("method run");        }    }    */    static Inter function()    {        return new Inter()        {            public void method()            {                System.out.println("method run");            }        };    }}

（四）、异常
1、什么是异常？
就是程序在运行时出现不正常情况，问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

2、异常问题的划分
两种：一种是严重的问题，一种非严重的问题。
①对于严重的，java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。

②对与非严重的，java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。

异常有两种：
①编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。
②运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。如：RuntimeException以及其子类。

3、异常的处理（格式）
java 提供了特有的语句进行处理。
try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；
}
注意：对捕获到的异常对象进行常见方法操作。String getMessage()：获取异常信息。

4、在函数上声明异常。
便于提高安全性，让调用出进行处理。不处理编译失败。

5、对多异常的处理。
①声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
②对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

6、自定义异常
1、如果项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。
将特有的问题。进行自定义的异常封装。

2、如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。

3、注意
自定义异常：
必须是自定义类继承Exception。

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

4、throw和throws的区别
throws使用在函数上。
throw使用在函数内。

throws后面跟的异常类。可以跟多个。用逗号隔开。
throw后跟的是异常对象。

5、Exceptoin中有一个特殊的子类异常RuntimeException
Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。

如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；

之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，
对代码进行修正。

自定义异常时：如果该异常的发生，无法在继续进行运算，
就让自定义异常继承RuntimeException。

对于异常分两种：
1，编译时被检测的异常。

2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)

练习：
例子

/*毕老师用电脑上课。开始思考上课中出现的问题。比如问题是    电脑蓝屏。    电脑冒烟。要对问题进行描述，封装成对象。可是当冒烟发生后，出现讲课进度无法继续。出现了讲师的问题：课时计划无法完成。*///自定义蓝屏异常class LanPingException extends Exception{    LanPingException(String message)    {        super(message);    }}//自定义冒烟异常class MaoYanException extends Exception{    MaoYanException(String message)    {        super(message);    }}class NoPlanException extends Exception{    NoPlanException(String msg)    {        super(msg);    }}//电脑类class Computer{    private int state = 3;    public void run()throws LanPingException,MaoYanException    {        if(state==2)            throw new LanPingException("蓝屏了");        if(state==3)            throw new MaoYanException("冒烟了");        System.out.println("电脑运行");    }    public void reset()    {        state = 1;        System.out.println("电脑重启");    }}//老师类class Teacher{    private String name;    private Computer cmpt;    Teacher(String name)    {        this.name = name;        cmpt = new Computer();    }    public void prelect()throws NoPlanException    {        try        {            cmpt.run();                 }        catch (LanPingException e)        {            cmpt.reset();        }        catch (MaoYanException e)        {            test();            //把冒烟异常转换为老师的异常            throw new NoPlanException("课时无法继续"+e.getMessage());        }        System.out.println("讲课");    }    public void test()    {        System.out.println("练习");    }}class ExceptionTest {    public static void main(String[] args)     {        Teacher t = new Teacher("毕老师");        //捕获异常并处理异常        try        {            t.prelect();        }        catch (NoPlanException e)        {            System.out.println(e.toString());            System.out.println("换老师或者放假");        }    }}

6、异常声明中的finally代码块：定义一定执行的代码。
通常用于关闭资源。

7、总结
异常的三种格式

第一个格式：
try
{

}
catch ()
{
}

第二个格式：
try
{

}
catch ()
{
}
finally
{

}

第三个格式：
try
{

}
finally
{
}
注意：记住一点：catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明。

8、异常在子父类覆盖中的体现；
①子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
②如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
③如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。

练习：

package cn.dhjYuju;/*有一个圆形和长方形。都可以获取面积。对于面积如果出现非法的数值，视为是获取面积出现问题。问题通过异常来表示。现有对这个程序进行基本设计。*///调用者不用处理异常，运行时异常是要再出现时，让程序停止public class Test001 {    public static void main(String[] args){        Rec a = new Rec(-3,4);        a.getArea();    }}//定义一个运行时的异常class NoValueException extends RuntimeException{    NoValueException(String message){        super(message);    }}//抽取圆和长方形的共性interface Sheap{    void getArea();}//定义圆的类，内部抛出异常class Circle implements Sheap{    private double radius;    public static final double PI = 3.14;    Circle(double radius){        if(radius <=0)            throw new NoValueException("不能为负数");        this.radius = radius;    }    public void getArea(){        System.out.println(radius*radius*PI);    } }//定义长方形类，并局部抛出异常class Rec implements Sheap{    private double len,wid;    Rec(double len,double wid){        if(len<=0 || wid <=0)            throw new NoValueException("不能为负数");        this.len = len;        this.wid=wid;    }    public void getArea(){        System.out.println(len*wid);    } }

注意：
如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。

增加知识点:java中的包机制
1、什么是java中的package？
在java中，管叫包，相当于文件夹。包里通常存放的是类文件，因为我们在编写程序的时候，难免会有类名相同的情况，就如我们人名一样。为了对类进行分类管理，java就有了包的出现，在不同包中可以有相同的类名，调用的时候连同包名一起就行。
包也是一种封装形式。在包中可以有很多类文件，但是只提供一个类文件，供外界使用。

2、package有什么作用？
①为避免多个类重名的情况，如果出现两个相同名字的类，可通过包将两者区分，从而避免冲突。
②对类文件进行分类管理，可以将相关的一些类放在同一个包中。
③给类提供多层命名空间，如a包中的Demo.class文件，如果要创建Demo对象，就要在使用时加上a.如：a.Demo demo=new a.Demo（）；
④包的出现可以将java的类文件和源文件相分离。

3、package的相关规则
①包必须写在程序的第一行。因为要先有包，才知道类文件的存放地方。
②类的全称：包名.类名。
③编译定义了包的程序文件时，在编译时要指定包的存储目录。
如：javac –d c:\mypack类名.java

4、包与包之间的相互访问
总结：
包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。

包与包之间可以使用的权限只有两种，public protected。
public protected default private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok ok
不同包中 ok

5、包的导入
可以简化类名。在调用其他包中的类时，需要写类的全称，也就是连同包名一起书写。当类存在多层包中时，如：haha.hehe.pack.Demo，使用import导入后，使用其类时，就可以不加包名了。导入格式如：import haha.hehe.pack.Demo;

注意：
①在导入包时，如果包中有很多类，可以使用通配符 来替代包中的所有类。但是，建议不要使用通配符 ，因为将不需要使用的类导入后，会占用内存空间。所有在编写程序时，要使用包中的哪些类，就导入哪些类。
②定义包名不要重复，可以使用url来完成定义，url是唯一的。如：package cn.itheima.Demo。
③导入的不同包中有相同类时，必须写类的全名以区分，否则将会报错。

6、jar包
类越来越多，我们可以用包来装，当包越来越多时，我们可以将包进行压缩。而java中用jar这个工具来对包进行压缩。压缩后的后缀名为jar。

注意：
jar.exe工具的一些命令：
①创建jar包
jar -cvf mypack.jar packa packb
②查看jar包
jar -tvf mypack.jar [>定向文件]
③解压缩
jar -xvf mypack.jar
④自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb