Java基础——面向对象——继承、抽象类、接口、多态、包、内部类、异常等

第一讲　　继承　　 1、继承：

　　当多个类拥有相同的功能时，那么这些类不需要每个都写这些相同的功能，只需要把相同功能抽到

一个单独的类中，继承这个类就能获得这些相同的功能；

(1)继承的体系结构：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。

• 要了解这个体系结构中最共性的内容,就看最顶层的类。
• 要使用这个体系的功能,就用最底层的类创建对象

（2）好处：

A、提高代码复用性：

B、继承的出现，让类与类之间产生关系，为多态的前提

（3）特点；

A、只能单继承（准确的说是java对多继承进行优化，避免安全问题），可以用多实现解决单继承的局限

B、但能多重继承

（4）注意：

A、子类可以直接访问父类中的非私有属性和行为

B、不要仅仅为了获取部分功能而继承

C、子夫类之间有所属关系才是继承

　　*如何判断A和B是否是继承关系呢？当A继承B时，A is one of B;

2、子类继承父类后成员关系：

（1)成员变量

class Fu{
    int num=5;
}

class Zi extends Fu{
    
    int num=20;
    
    public void show(){
        int num=30;
        System.out.println("num="+num);//30
//        当局部变量与成员变量重名时使用this区分
        System.out.println("this.num+"+this.num);//答案20
//        当字类和父类出现同名变量时，用supeu
        System.out.println("super.num"+super.num);
//    总结：在子类继承夫类中，变量名出现重复，优先级是局部变量——成员变量——父类变量；但是成员可用this父类变量
//        用super，来调用
    }
}

（2)成员方法——重载和重写（覆盖，复写）的区别

class Fu{
    public void show(){
        System.out.println("fu show");
    }
}

class Zi extends Fu{
    
    public void show(){
        System.out.println("zi show");
    }
}
/*子类继承父类后，存在于修饰符、方法名、参数列表相同的现象，叫做重写、覆盖、复写
重写（override）和重载（overLoad）的区别：
重载：
    在同一个类长
    方法名相同，参数列表不同
重写：
    在子类继承父类中
    子类有一个返回类型、方法名、参数相同的方法
    注：覆盖是，子类的权限大有法雷
    父类的权限不能私有
    静态只能覆盖静态
*/

 final作为一个修饰符。具有以下特点：

        1、可以修饰类、函数、变量。

        2、被final修饰的类不可以被继承。这样就可以避免被继承、被子类复写功能。

        3、被final修饰的方法不可以被复写。

        4、被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量

（3）构造方法

class Zi2 extends Fu2{
    Zi2(){
//        super();this和super不能一起
        this(40);
        System.out.println("son");
    }

    Zi2(int age){    
        super();//子类中所以的构造方法默认都会访问父类长空参数的构造方法
        System.out.println("son age:"+age);
    }
}


public class Demo23 {
    public static void main(String[] args){
//        Zi2 z = new Zi2();  

        Zi2 z2 = new Zi2(30);
    }    
}
/*总结：子类中所有构造方法默认有super（）；
        
    当父类没有空参数的构造方法时，子类的构造函数必须通过this或者
    super指定眼访问的构造方法。
    
    构造函数用于创建对象，并初始化；建议你如果写了有参的构造函数，也需要把无参的构造函数协商
    否则你定义了一个有参数的构造函数，空参数的系统就不会在给了；
    
*/

以下是类中构造函数的方法实例；

class Person{
    int age;
    String name;
    Person(){}//添加一个空参
    
    Person(int age){
        this.age=age;
    }
    Person(int age,String name){
        this(age);//代替this.age=age;
        this.name=name;
    }    
}
    //Person p=new Person();系统默认给出无参构造函数
//        当你收到给出构造函数后，系统就不会给出默认的空的构造方法

 

　第二讲　　抽象类、接口

1、概念：抽象就是从多个事物中将共性的本质的内容抽取出来

例如：狼和狗共性都是犬科，犬科就是抽象出来的概念；

 

2、特点：

　　A\抽象类和抽象方法必须用abstract修饰

　　B、抽象方法只有声明，没有具体方法

　　C、抽象类不可以实例化，不可以通过new创建对象

　　D、抽象类通过其子类实例化，而子类需要覆盖抽象类所有的抽象方法才能创建对象；

3、与一般类的区别：

　　1、抽象类比一般类至少多一个抽象函数，

　　2，抽象类不能实例化

　　3、抽象类虽然不能创建对象，但是也有构造函数。供子类实例化调用的；

注：被abstract修饰的函数不能同时被private、final,static修饰。

原因：

　　final没有子类，private不能复写，static可以修饰抽象方法，那么连对象都省了，直接调用类名即可；

4、抽象有一个特殊的地方：抽象类中可以不定义抽象方法。这样做可以不让本类实例化，也可以用于模块设计：

abstract class GetTime{
    
    public final void getTime(){//使用final使其不能被复写
        long start=System.currentTimeMillis();
        propgram();
        long end=System.currentTimeMillis();
        System.out.println("程序用时"+(end-start));
    }
    abstract void propgram() ;
}

//子类的程序
class program extends GetTime{
    void propgram() {        
        for(int i=0;i<1000;i++)
            System.out.println("水音大美女");
    }    
}


new program().getTime；

 

5、接口（interFace）

（1）概念：当一个类长所有的方法都是抽象的时候，定义为接口；

（2）成员的特点：

A、只有成员变量和成员方法；

B、成员变量默认修饰符public static final

　　*int x=20实际上是public static final int x=20；

C：成员方法默认修饰符：public abstract

　　void show()实际上是public abstract void show（）

（3）接口解决了单继承的问题

　　A、类与类只能extend，一次

　　B、接口与接口之间：可以单继承，也可以多继承：extends，implements

　　C、类与接口之间：当实现，也可以多实现：implements

（4）接口的特点：

接口时对外暴露的规则；是功能的扩展；

接口降到了程序的耦合性：

内聚：自己实现功能的能力；

高内聚，低耦合；

举例：USB接口

（5）接口和抽象类的区别：

A：抽象类单继承，接口多实现

B：

　　*抽象类的成员：

　　　　*成员变量：常量或变量

　　　　*成员方法：抽象或非抽象

　　　　*构造方法：可以有，为了给子类实例化用的；

　　*接口的成员

　　　　*成员变量只能常量：默认修饰符：public abstract final

　　　　*成员方法：只能抽象；默认修饰符：public abstract

C:抽象类定义的是体系结构中的共性内容，接口定义的是对象的扩展功能

D：抽象类被继承的表达的是：is a的关系，接口被实现表达的是like a的关系

接口的实例：

//抽象学生类,睡觉和学习是共性的，吸烟是额外的接口的
abstract class Student{
    
//    抽象学习方法
    abstract void study();
    
    void sleep(){
        System.out.println("sleep");
    }
}

interface Smoking{
    public abstract void smoke();
}
//zhangs是继承学生，而实现吸烟
class Zhangs extends Student implements Smoking{
//    复写学习
    void study(){
        System.out.println("zhang_xue");
    }
//    复写吸烟
    public void smoke(){
        System.out.println("zahgns_smoke");
    }
}
//lili是好学生
class lili extends Student{
//    复写study即可
    void study(){
        System.out.println("lili_study");
    }
}

//主函数
    new zhangs().study();
    new zhangs().smoke();
    new lili().study();

 

第三讲　　多态

1、概念：事物存在的多种体系形态；如猫既可以猫科也可以是动物

　　*方法重载（静态多态）：

　　*方法重写（动态多态，对象多态）

2、对象多态的前提

　　A、类与类（接口）有继承或实现关系

　　B、一定要有方法重写（覆盖、复写）

　　C、一定要有父类或接口的引用指向子类的对象

3、多态中成员的特点：例如 Fu f=new Zi();

A:成员变量：编译和运行都看Fu；

B：非静态变量：编译看Fu，运行看Zi；

C：静态方法:编译运行都看Fu；

举例：动物栗子向上转型：Animal a=new cat（）；a。eat();//a.catchMouse();

向下转型
Cat a=(Cat)a;
c.eat();
c.catchMouse();

向上转型
Animal a=new Dog();
//一下错误
Cat c=(Cat)a;
Dog d=(Dog)a;

4、多态的好处与弊端：

　　好处：提高程序的扩展性

　　弊端：不能使用子类特有的属性和行为；

5、多态的实例运用;

步骤：1、定义好工具类，即将共有行为封装在一个类中；　　　　

　　　2、对类型进行抽取-————多态的产生

　　　3、操作同一个夫类型，对其中的子类型均可操作

实例小程序：

/*
 * 电脑运行实例：电脑的运行由主板控制，上网和听歌需要网卡和声卡额外提供，这是
 * 可以定义一个规则，叫做PCI。只有符合这个规则的网卡和声卡都可在主板上使用，这样就降低了主板
 * 和网卡、声卡的耦合性
 */

//接口PCI
interface PCI{
    public abstract void open();
    public abstract void close();
}

//网卡实现接口
class NetCard implements PCI{
    
    public void open(){
        System.out.println("Net_open");
    }
    
    public void close(){
        System.out.println("New_close");
    }
}


//声卡实现接口
class SoundCard implements PCI{
    
    public void open(){
        System.out.println("Sourd_open");
    }
    
    public void close(){
        System.out.println("Sound_close");
    }    
}
//主板
class Mainboard{
//电脑运行    
    public static void run(){
        System.out.println("Mainboard_run");
    }
//    使用扩展功能
    public static void usePCI(PCI p){//这里参数放的是父类，代表父类和继承父类的类都能放入
        if(!(p==null)){
            p.open();
            p.close();
        }
    }
}

class Demo23{
    public static void main(String[] args){
        Mainboard m=new Mainboard();
//        电脑运行
        m.run();
//        上网
        m.usePCI(new NetCard());
//        听歌
        m.usePCI(new SoundCard());
    }    
}

 

第四讲　　扩展知识：包、内部类、异常

一、package包，包就是文件夹

1、定义包：使用package关键字在类的第一条语句定义包名，包名全部小写

2、编译带包名的类

　　-javac -d<目录>源文件名.java

　　如：-javac -d.Person.java

3\默认包

　　*如果一个类没有加上package关键字定义包名，它是一个默认的保重，在没有定义包之前默认在一个包中，可以直接访问

　　*如果两个雷定义了包，并且相同的包，可以直接访问

4、运行带包的文件

　　-java 包.类

　　例如：java cn.afs.sf.PackageDemo

5、访问权限

　　private：当前类可以使用

　　默认：同包类可以使用；

　　protected保护：同包中的类和子类可用

　　public 公用的，如果希望被外包使用而添加public，而且public的类必须和文件名一致

 

6、导入其他包中的类

　　首先该类必须是public　　

　　使用import导入其他包中的类；

　　　　A、*代表所有类　　　　　　如:import java.Lang.*;

　　　　B、写入具体的比较省内存　　　　如:import java.util.Scanner;

7、注意项：

写类的时候要加上包名
类要public, 并且类名和文件名一致
导入类要写类名
编译用-d, 运行带包名

 

二、内部类：定义在一个类中的类，称为内部类

（1）成员内部类：

　　A：定义：在一个外部类中有成员变量和成员方法，那么成员内部内就是整个一个类当成外部类的成员对待

　　B：访问规则：1、内部类可以直接访问外部类中的成员，包括私有的

　　　　　　　　　　内部类之所以能访问外部类的成员，是因为有引用：外部类名.this.

　　　　　　　　  2、外部类要访问内部类，必须建立对象

 

（2）访问格式：　　　　Outer.Inner in=new Out().new Inner();

 (3）修饰符：final、abstract、public、private、protected和static　　

（4）静态内部类（被static修饰）

　　A、定义在外部类中的内部类加static修饰

　　B、格式：Outer.inner in=new Outer.Inner();

　　C　方法也是静态的：Outer.Inner.Function();

　　记住：静态成员用类名调用的原则就行了

　　注意：内部类的方法静态，那么外部类也必须静态

　　　　　外部类的静态方法不能访问非静态的内部类

 

（5）局部内部类（在外部类方法中定义内部类，它更像是局部变量）

　　注意：1、不可以被成员变量修饰符修饰：如static

　　　　   2、可以直接访问外部类中的成员，因为用引用；

　　　　　　但是不能访问它所在反复局部的变量，除非该变量被final修饰；

 

class Outer  
{  
    int x = 3;  
    void method(final int a)  
    {  
        final int y = 4;  
        //局部内部类  
                class Inner  
        {  
            void function()  
            {  
                System.out.println(y);  
            }  
        }  
        new Inner().function();//使用局部内部类中的方法。  
    }  
}  
class  InnerClassDemo  
{  
    public static void main(String[] args)   
    {  
        Outer out = new Outer();  
        out.method(7);//打印7  
        out.method(8);//打印8  
    }  
}  

　　　　　*方法内部类的修饰符。与内部类不同，方法内部类更新一个局部变量。可以用于修饰方法内办理的只有final和abstract

　　　　　*静态方法内的方法内部类。静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能范围外部的静态成员

interface Inter {
    public abstract void show1();
    public abstract void show2();
}

//有名字的内部类
class Outer {
   int x=3;
        class Inner implements Inter {
            int x=4;
            public void show1(){
                x=5;
                System.out.println("show1"+x);
                System.out.println("show1"+this.x);
                System.out.println("show1"+Outer.this.x );
            }

            public void show2(){
                System.out.println("show1");
            }
        
    }
    public void show() {
        Inter in = new Inner();//父类引用指向子类对象
        in.show1();
        in.show2();

    }
}

 

（6）匿名内部类（重点）

　　概念：木有名字的内部类，可以直接定义方法

实例：

//匿名内部类（在android里面用的多，awt的监听器使用较多）
class OuTer{
    public void mehtod(){
//        匿名内部类对象调用方法
        new Inter(){
            public void show1(){
                System.out.println("show1");
            }
            public void show2(){
                System.out.println("show2");
            }
        }.show1();
        
        new Inter(){
            public void show1(){
                System.out.println("show1");
            }
            public void show2(){
                System.out.println("show2");
            }
        }.show2();
                
    }
//    方法2
    Inter in =new Inter(){
        public void show1(){
            System.out.println("show1");
        }
        public void show2(){
            System.out.println("show2");
        }
    };
    in.show1();
    in.show2();    
}

使用范围：通常在使用方法是接口类似参数，并该接口中的方法只有1~3个时，可以将匿名内部类作为参数传递

 

 

 异常

 一、概述：异常就是程序运行时出现不正常情况。

 二、异常体系

 对两种问题划分的方式：

　　一种是严重的问题，通过Error类描述，补编写针对性的代码进行处理

　　一种是非严重的文艺，通过Exception类进行描述，对应Exception可以使用针对性的处理

Java的异常体系：

Throwable　　

　　|--Error:重大的问题，无法解决

　　|--Exception:运行时出现的一些情况

　　　　|-R　　各种异常一般以Exception结尾

异常体系的特点：

　　1、异常体系中的所有类以及建立的对象都具备可抛性；

　　2、也就是说可以被throw和throws关键字操作

　　3、只有异常体系具备这个特点

异常的格式

try{

　　需要被检测的代码　　

}catch（异常类 变量）{

　　处理异常的代码（处理方式）

}

finally{

　　最后执行的语句（一定被执行）

}

throw和throws的用法：

　　throw定义在函数内，用于抛异常对象

　　throws定义在函数上，用于抛异常类，可以用逗号分开抛多个异常

调用者对抛出异常的处理

　　当函数内出现throw抛出异常对象，那么就必须要给对应的处理动作，哟啊么try{}catch{}要么在函数上声明让调用者处理

　　函数内出现异常，函数上需要声明可能的异常

注意：

　　Exception有一个特殊的子类RuntimeException运行时异常

　　　　1）如果函数内抛该异常，函数不用声明

　　　　2）如果函数上声明该异常，调用者不用进行处理

　　之所以不用上门，因为该异常发生，是希望程序停止。

对捕获到的异常对象进行常见方法操作;

　　String getMessage();//获取异常的信息，返回字符串

　　toString（）：获取异常类名和异常信息，返回字符串

　　printStackTrace（）；获取异常类名和异常信息，以及异常出血在程序中的位置，返回true

　　　　　　　　　　　　　　JVM默认的异常处理机制，就是调用printStackTrace方法打印异常的堆盏信息

　　printStackTrace（PrintStream s）//通常该方法将异常内容保存在日志文件中，以便查询

 

自定义异常：

　　当出现的异常java并未描述，可以自定，以便继承Exception或RuntimeException

　　　　1、为了让该自定义类具备可抛性

　　　　2、让该类具备自定义类可抛性

这叫做自定义异常

如：

class ZiDingYiException extends Exception{
    private String msg;
    ZiDingYiException(String msg){
        super(msg);
    }
}

 

异常的好处和原则

好处：

　　1、将问题进行封装；

　　2、将正常流程代码和问题处理代码分离，方便阅读

原则：

　　1、处理方式有两种：能try不throws

　　2、调用到抛出异常的功能时，抛出几个处理几个，一个try可以多个catch

　　3、多个catch是父类写下面，不然子类没法执行

　　4、catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace

/电脑蓝屏了  
class BlueScreenException extends Exception  
{  
    BlueScreenException(String message)  
    {  
        super(message);  
    }  
}  
//电脑起火了  
class FireException extends Exception  
{     
    FireException(String message)  
    {  
        super(message);  
    }  
}  
  
//老师无法继续上课  
class StopException extends Exception  
{     
    StopException(String msg)  
    {  
        super(msg);  
    }  
}  
class Computer  
{  
    int start=1;  
    //电脑启动  
    void run()throws BlueScreenException,FireException  
    {  
        if(start==2)  
            throw new BlueScreenException("Computer_BlueScreen");  
        else if(start==3)  
            throw new FireException("Computer_FireBreaking");  
        System.out.println("Computer_run");  
    }  
    //电脑重启  
    void reset()  
    {     
        start=1;  
        System.out.println("Computer_reset");  
    }  
}  
  
class Teacher  
{  
    private String name;  
    private Computer cpt;  
  
    //对老师进行初始化  
    Teacher(String name)  
    {  
        this.name=name;  
        cpt=new Computer();  
    }  
  
    //老师开始讲课  
    public void teach()throws StopException  
    {  
        try  
        {  
            cpt.run();  
              
        }  
        catch (BlueScreenException e)  
        {  
            //System.out.println(e.getMessage());  
            cpt.reset();  
        }  
        catch (FireException e)  
        {  
            test();  
            //System.out.println(e.getMessage());  
            throw new StopException("Teather_StopTeach："+e.getMessage());  
        }  
  
        System.out.println(name+"Teacher_teaching");  
    }  
    void test()  
    {  
        System.out.println("学生做练习");  
    }  
  
}  
class ExceptionTest  
{  
    public static void main(String[] args)   
    {  
        Teacher t=new Teacher("毕老师");  
        try  
        {  
            t.teach();  
        }  
        catch (StopTeachException e)  
        {  
            System.out.println(e.toString());  
            System.out.println("换老师或者放假");  
        }  
    }  
}