关于java:JAVABasis-4-3-面向对象

35次阅读

共计 6740 个字符，预计需要花费 17 分钟才能阅读完成。

1 异样

1.1 概念：

程序在运行的过程之中，呈现导致程序无奈失常运行的问题，Java 中的异样指的是用来封装导致程序无奈失常运行的错误信息的类，组成构造是：类型 + 提示符 + 行号

1.2 分类：


Throwable：Java 中任何异样类的父类，代表了所有的异样类所具备的独特属性。
Error：（不可查异样，不要求强制解决）指的是程序产生了重大的零碎不可解决的问题。
Exception：（可查异样，必须解决）指的是程序产生了零碎能够解决的异样问题。
RuntimeException：指的是运行时异样，程序能够抉择捕捉解决，也能够不解决。
IOException：指的是非运行时异样，这类异样时必须进行解决的异样。

1.3 异样解决

程序中遇到了异样，通常有两种解决形式：捕捉和向上抛出

1.3.1 捕捉异样：

try-catch
try{须要捕捉的异样代码}catch(异样类型 异样名字){解决形式}
try-catch-finally
try{须要捕捉的异样代码}catch(异样类型 异样名字){解决形式}finally{代码块（用于回收资源）}
案例

    package com.mtingcat.javabasis.object.exception;
    
    import java.util.Scanner;
    
    /**
     * 测试异样
     * @author MTing
     *
     */
    public class DomeException {public static void main(String[] args) {System.out.println("Input your number:");
            /**
             * 把可能产生异样的代码放到 try 代码块外面，一旦
             * 产生异样就会执行 catch 中的代码。*/
            try {@SuppressWarnings("resource")
                int a = new Scanner(System.in).nextInt();
                @SuppressWarnings("resource")
                int b = new Scanner(System.in).nextInt();
                System.out.println("a / b =" + a/b);
            } catch (Exception e) {System.out.println("Input error");
            }
            System.out.println("end");
        }
    
    }


    package com.mtingcat.javabasis.object.exception;
    
    import java.util.Scanner;
    
    /**
     * 测试异样
     * @author MTing
     *
     */
    public class DomeException {public static void main(String[] args) {System.out.println("Input your number:");
            /**
             * 把可能产生异样的代码放到 try 代码块外面，一旦
             * 产生异样就会执行 catch 中的代码。*/
            try {@SuppressWarnings("resource")
                int a = new Scanner(System.in).nextInt();
                @SuppressWarnings("resource")
                int b = new Scanner(System.in).nextInt();
                System.out.println("a / b =" + a/b);
            } catch (Exception e) {System.out.println("Input error");
            }finally {  // 用于回收资源
                System.out.println("finally");
            }
            System.out.println("end");
        }
    
    }

2 拜访控制符

用来管制一个类或者类中的成员的拜访范畴。
public：公共拜访权限，被这个关键字润饰的成员或者类能够被其余所有的类拜访。
protected：子类拜访权限，被这个关键字润饰的成员或者类能够被同包中的类拜访，也能够被不同包中的子类拜访。
default：包拜访权限：被这个关键字润饰（无拜访润饰关键字）的成员或者类能够被雷同包下的其余类拜访。
private：以后类拜访权限，被这个关键字润饰的成员或者类只能在以后类的外部被拜访。

类 包 子类 任意类
public √ √ √ √
protected √ √ √
default √ √
private √

3 抽象类

3.1 概念

Java 中能够定义没有办法体的办法，该办法由其子类来具体的实现。该没有办法体的办法咱们称之为形象办法，含有形象办法的类咱们称之为抽象类，抽象类能够了解为是一个只有办法申明没有办法体的非凡类，抽象类是为了继承，Java 是单继承，意味着一个父类中能够有多个子类，然而一个子类只能有一个父类 抽象类中的形象办法是为了子类在继承抽象类时不同的行为能够被不同的子类进行别离实现。

修饰符 abstract 返回值 办法名(参数列表);

3.2 特点

① 通过 java 关键字 abstract 实现
② 能够润饰办法或者类
③ 抽象类中能够没有形象办法（由子类去实现）
④ 如果类中有形象办法，那该类必须定义为一个抽象类
⑤ 子类继承了抽象类当前，要么还是一个抽象类，要么就把所有形象办法都重写
⑥ 多用于多态中
⑦ 抽象类不能够被实例化

3.3 案例

3.1 设计思路：

① 将所有子类的共性属性和办法抽取到父类中 —- 抽共性。
② 所有子类的行为都一样，设计成不同办法。
③ 所有子类的行为都不一样，设计成形象办法。

3.2 规定

① 抽象类也有构造方法，然而不能自身实例化。
② 既能够有变量，也能够有常量。
③ 抽象类里，既能够有一般办法，有能够有形象办法。

抽象类
package com.mtingcat.javabasis.abstract11;
/**
 * 抽象类
 * @author MTing
 *
 */
public abstract class abstractAnimals {
    // 抽象类中的一般属性
    String name;
    // 抽象类中的形象办法, 一个类中如果有形象办法，那么这个类必须是抽象类，子类中必须重写
    public abstract String eat();
    public abstract String sleep();
    // 抽象类中的一般办法
    public String do01(){return "抽象类中的一般办法 do01()";
    }

}
子类
package com.mtingcat.javabasis.abstract11;

public class extendsAnimals extends abstractAnimals{
    
    String sex;
    int age;
    public String run(){return "子类增加的办法 run()";
    }
    @Override
    public String eat() {return "重写了抽象类形象办法 eat()";
    }

    @Override
    public String sleep() {return "重写了抽象类形象办法 sleep()";
    }

}
一般类

package com.mtingcat.javabasis.abstract11;

public class Cat {public static void main(String[] args) {extendsAnimals mtingCat = new extendsAnimals();
        System.out.println(mtingCat.eat());
        System.out.println(mtingCat.sleep());
        System.out.println(mtingCat.do01());
        mtingCat.name = "MTingCat";
        mtingCat.age = 10;
        mtingCat.sex = "boy";
        System.out.println(mtingCat.name+","+mtingCat.age+","+mtingCat.sex);
    }

}

3.4 抽象类的意义

① 封装了子类所有的办法和行为，进步代码的可用性。
② 为子类提供一个对立的造型形式 – 向上造型。
③ 能够蕴含形象办法，为子类提供对立的入口，子类的具体实现不同，然而入口统一。

4 成员外部类

类中套类，里面的类称之为 Outer 外部类，外面的类称之为 Inner 外部类。
外部类通常只服务于外部类，对外不具备可见性。
外部类对象通常须要在外部类中被创立
外部类能够间接拜访外部类的成员(蕴含公有的)，外部类有一个隐式的援用指向创立它的外部类对象外部类名.this.

5 匿名外部类

若想创立一个类 (派生类) 的对象，并且该对象只被创立一次，此时该类不用命名，称之为匿名外部类。
外部类中拜访里面的变量，该变量 jdk1.7(蕴含)以前必须是 final 的

6 接口

6.1 接口的概述

ava 外面因为不容许多重继承，所以如果要实现多个类的性能，则能够通过实现多个接口来实现。
Java 接口和 Java 抽象类代表的就是形象类型，就是咱们须要提出的形象层的具体表现。OOP 面向对象的编程，如果要进步程序的复用率，减少程序的可维护性，可扩展性，就必须是面向接口的编程，面向形象的编程，正确地应用接口、抽象类这些太有用的形象类型做为 java 构造档次上的顶层。

6.2 接口的模式

interface 接口名 {代码...}

6.3 接口的特点

① 接口是一种标准，冲破了 java 单继承的局景象，是抽象类的拓展。
② 通过 interface 关键字创立，通过 implements 关键字让子类实现。
③ 在接口中只能蕴含常量和形象办法。
③ 接口不能被实例化，接口和接口之间能够实现，也能够多继承。
⑤ 接口须要被实现 / 继承，实现类 / 子类要实现接口就必须重写接口中的形象办法。
⑥ 一个类能够工夫多个接口，接口之间用逗号分隔，如果又继承又实现，应该是先继承后实现。
⑦ 接口进步了程序的性能扩大，升高了耦合性。

6.4 案例

package com.mtingcat.javabasis.interface10;
/**
 * 对于接口的入门案例
 * @author MTing
 *
 */
public class entryLevelDemo {@SuppressWarnings("static-access")
    public static void main(String[] args) {S s01 = new S();
        SSS s02 = new SSS();
        s01.name = "Tom";
        s01.id = 01;
        s01.work();
        System.out.println(s01.study());
        System.out.println("student:"+s01.name+"id:"+","+s01.id);
        System.out.println(s01.studyPlace+s01.studyGroup);
        System.out.println(s02.input());
        
        
        
    }
}

class SSS extends S implements C,Person {public String input(){return "继承的同时实现";}
}

class S implements Student,C{
    
    String name;
    Integer id;

    @Override
    public String study() {return "实现类重写了接口办法 student（）";}

    @Override
    public void work() {System.out.println("实现类重写了接口办法 work（）");
    }

    @Override
    public void show() {// TODO Auto-generated method stub}
    
}

/**
 * 接口 Student 继承了接口 Person 和 Behave，体现了接口多继承的个性
 * @author MTing
 *
 */
interface Student extends Person,Behave{
    public static final String studyPlace = "school";
    String studyGroup = "class";
    
}

interface Behave{public abstract String study();
    void work();}


interface Person{public abstract void show();
}
interface C{}

6.5 接口的用法

6.5.1 构造方法

接口外面没有构造方法，在创立实现类的对象时默认是 super()，调用默认的是 Object()无参结构。


interface Person{public abstract void show();
}

6.5.2 成员变量

接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上 public static final

interface Student extends Person,Behave{
    public static final String studyPlace = "school";
    String studyGroup = "class";
    
}

6.5.3 接口的成员办法

接口里的办法，默认就都是形象的，如果你不写明是 abstract 的，那会主动补齐。
例如：public abstract void save

interface Behave{public abstract String study();
    void work();}

6.5.4 接口的简单用法

Java 中单继承的局限性通过接口能够解决。
接口能够多继承也能够多实现，甚至能够继承的同时多实现。

class SSS extends S implements C,Person {public String input(){return "继承的同时实现";}
}

interface Student extends Person,Behave{
    public static final String studyPlace = "school";
    String studyGroup = "class";
    
}

6.6 总结

1 类和类的关系：继承 extends / 单继承 / 单根继承

— 继承的意义：为了进步代码的复用性，缩小了代码的编写进步开发效率。
— 办法重写的意义：在不批改父类源码的前提下，在子类中重写业务，从此应用的就是重写后的性能。
— 要求子类的办法申明和父类一样，只有改办法体。
— 有了继承有了重写就产生了多态，多态的意义：为了对立程序的调用规范，规范就是父类。
— 多态 也就是向上转型 / 向上造型。
— 向下造型的意义：很少用，相当于想要应用子类的非凡性能，还不如间接创立子类对象简略。
— class A extends B
— 其中，A 和 B 都是类，A 是子类，B 是父类，A 就领有了 B 的所有性能(除了公有的和构造方法)
— 其余知识点：this 和 super，构造方法，各种代码块 …

2 类和接口关系：实现 implements / 单实现 / 多实现

— class A implements B,C
— 其中，A 是实现类,B 和 C 是接口
— 要求 A 能够把 B 和 C 接口里的所有 形象办法 都重写掉，否则 A 就是抽象类
— 接口不能创建对象
— 接口里没有构造方法，接口里都是常量，接口里都是形象办法

3 接口和接口关系：继承 extends / 单继承 / 多继承

— 接口的多继承的关系，突破了 java 单继承的局限性
— interface A extends B,C
— 其中，A B C 都是接口，A 是子接口，同时领有 B 和 C 接口里的所有性能
— class AImpl implements A
— 要求 AImpl 须要重写 A 接口里的所有办法(是蕴含 B 和 C 接口的所有办法)，否则就是抽象类

4 接口和抽象类的区别！！！

— 相同点：都是形象层，都不能实例化
— 不同点：
— 1、抽象类用 abstract 关键字形容，接口用 interface
— 2、子类和抽象类之间是 extends 关系，实现类和接口之间是 implements 关系
— 3、抽象类中 能够 有构造方法，接口里 不能 呈现 构造方法
— 4、抽象类里能够有 变量，接口里没有变量全都是动态的常量
— 5、接口里定义常量的语法：public static final String NAME=”jack”，会为变量主动拼接 public static final
— 6、抽象类里 能够有一般办法 也能够有 形象办法，接口都是形象办法
— 7、抽象类和子类之间是继承关系，而且 java 中，只反对单继承
— 8、接口冲破了 java 单继承的局限性，因为接口能够多继承也能够多实现，甚至能够继承的同时多实现
— 9、接口的简单用法
— 多继承：interface A extends B,C 其中 A 是子接口，同时领有本人的和 BC 的性能
— 多实现：class AImpl implements M,N,O,P 其中 AImpl 是实现类，须要同时重写 MNOP 的所有形象办法，否则就是一个抽象类
— 继承的同时多实现：class AImpl extends Object implements M,N 肯定是先继承后实现

正文完
java
发表至： java
2020-09-17
 0
关于java:drools决策表的简单使用
关于java:组件使用阿里云的镜像仓库存储自己的镜像
漫画：程序员小赵的架构师之路
关于java:备忘录模式