慢慢懂的第七篇文章

最新推荐文章于 2024-05-24 02:08:26 发布

缘与风灯

最新推荐文章于 2024-05-24 02:08:26 发布

阅读量99

点赞数 1

分类专栏：学习Java 文章标签： java

本文链接：https://blog.csdn.net/m0_55682941/article/details/116073947

版权

学习Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java学习day07

多态

动态编译，可扩展性；

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象

多态注意事项:

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常! ClassCastException !
存在条件: 继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son(); .

不能重写的方法：

static 方法，属于类，它不属于实例
final 常量; .
private 方法;

注意:多态是方法的多态,属性没有多态性。

instanceof

    public static void main(String[] args) {
        Object s1 = new Student();
        //Object >String

        //Object >Person >Student

        //Object >Person >Teacher
        System.out.println(s1 instanceof Student);//ture
        System.out.println(s1 instanceof Person);//ture
        System.out.println(s1 instanceof Object);//ture
        System.out.println(s1 instanceof Teacher);//false
        System.out.println(s1 instanceof String);//false
        System.out.println("=================================");
        Person s2 = new Student();
        System.out.println(s2 instanceof Student);//ture
        System.out.println(s2 instanceof Person);//ture
        System.out.println(s2 instanceof Object);//ture
        System.out.println(s2 instanceof Teacher);//false
    }

public class Application {
    public static void main(String[] args) {
        //子类转换父类
        //父类的引用指向子类的对象
        Person student = new Student();
        //强制转换，子类可能丢失一些方法
        ((Student)student).go();
        
        Student student1 = (Student) student;
        student1.go();
    }
}

static

public class Main {
    private static  int age;
    private double score;
    
    public void run(){
        go();//非静态方法可以调用静态方法
    }
    public static void go(){
        //静态方法不能调用非静态方法
        //静态方法可以调用静态方法
    }
    public static void main(String[] args) {
        Main main = new Main();
        System.out.println(Main.age);//static可以使用类名.变量访问
        System.out.println(main.score);//非静态使用对象.变量
        System.out.println(main.age);
        new Main().run();//不能直接调用
        go();
    }
}

//静态导入包
import static java.lang.Math.random;

import static java.lang.Math.PI;

public class Demon01 {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(random());
        System.out.println(PI);
    }
}
//被final修饰的的类不能被继承

代码块

public class Main {
    static {//1.只会执行一次
    System.out.println("静态代码块");
}
    {//2.
        System.out.println("匿名代码块");
    }
    public Main() {//3.
        System.out.println("构造函数");
    }

    public static void main(String[] args) {

        Main main = new Main();
        System.out.println("================");
        final Main main1 = new Main();

    }
}

在这里插入图片描述

抽象类

public abstract class B {

    //abstract抽象类

        //抽象方法，只有方法名字没有方法的实现
        public abstract void dosomething();
        //抽象方法必须在抽象类中
    //抽象类可以写普通方法
    //不能new这个抽象类，只能靠子类去实现约束他
    }

//抽象类的所以方法，继承了它的子类，都必须要实现它的方法
//除非子类也是抽象类
public class A extends B{
    @Override
    public void dosomething() {

    }
}

接口

◆普通类:只有具体实现

◆抽象类:具体实现和规范(抽象方法)都有!

◆接口:只有规范!自己无法写方法专业的约束约束和实现分离，面向接口编程

◆接口就是规范，定义的是一组规则，体现了现实世界中“如果你…则必须能…的思想。如果你是天使，则必须能飞。如果你是汽车,则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。

◆接口的本质是契约，就像我们人间的法律- -样。制定好后大家都遵守。

◆00的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++. java. c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。


//interface 关键词  接口都需要有实现类
public interface Userservice {

    //常量   public static final
    public static final int add=99;

    //接口里面所有的定义都是抽象的 默认public abstract
    void run(String name);
    void add(int a,int b);

}

public interface Timeservice {

    void timer();
    void eat();
}


//抽象类 extend
//接口 可以实现接口 implements
//实现了接口的类，就必须实现接口的方法
public class Userservice1 implements Userservice,Timeservice{//多继承
    @Override
    public void run(String name) {

    }

    @Override
    public void add(int a, int b) {

    }

    @Override
    public void timer() {

    }

    @Override
    public void eat() {
    }
}

内部类

public class Main {
    public static void main(String[] args) {
        Demon01 demon01 = new Demon01();
        //通过外部类来实例化内部类
        Demon01.Inner inner= demon01.new Inner();
        inner.in();
        inner.getId();

    }
}

public class Demon01 {
    private int id =2;
    public void out(){
        System.out.println("这是内部类");
    }
    public class Inner{
        public void in(){
            System.out.println("这个是内部类");
        }
        public void getId() {
            System.out.println(id);
        }

    }

}

在这里插入图片描述

异常机制

◆实际工作中，遇到的情况不可能是非常完美的。比如:你写的某个模块，用户输入不一定符合你的要求，你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了。等等。

◆软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常,英文是:

Exception，意思是例外。这些,例外情况，或者叫异常,怎么让我们写的程序做出合理的处理。而不至于程序崩溃。

◆异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。

◆异常发生在程序运行期间,它影响了正常的程序执行流程。

◆Java把异常当作对象来处理，并定义-个基类java.lang.Throwable作为所有异常的超类。

◆在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception.

在这里插入图片描述

Exception

. 在Exception分支中有一个重要的子类RuntimeException (运行时异常)

◆ArrayIndexOutOfBoundsException (数组” 下标越界)

◆NullPointerException (空指针异常)

◆ArithmeticException (算术异常)

◆MissingResourceException (丢失资源)

◆ClassNotFoundException (找不到类)等异常,这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

◆这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生;

◆Error和Exception的区别: Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机(JVM) -般会选择终止线程; Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

Error

◆Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

◆Java虛拟机运行错误(Virtual MachineError)，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虛拟机(JVM) 一般会选择线程终止;

◆还有发生在虚拟机试图执行应用时，如类定义错误(NoClassDefFoundError) 、链接错误(LinkageError)。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

异常抛出

public class Text {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("程序出现异常，b不能为0");
        }finally {//善后，可以不要
            System.out.println("finally");
        }
    }
}

在这里插入图片描述


public class Text {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {//从小到大捕获
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("程序出现异常，b不能为0");
        }catch (Error e){
            System.out.println("Error");
        }
        catch (Exception e){
            System.out.println("Exception");
        }catch (Throwable t) {
            System.out.println("Throwable");
        }
            finally {
            System.out.println("finally");
        }
    }
}

快捷键command+option+T

自定义异常

◆使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类,只需继承Exception类即可。

◆在程序中使用自定义异常类，大体可分为以下几个步骤:

创建自定义异常类。
在方法中通过throw关键字抛出异常对象。
如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下-步操作。
在出现异常方法的调用者中捕获并处理异常。

public class MyException extends Exception{
    private int detial;
    public MyException(int a){
        this.detial=a;
    }
    //toString异常的打印信息
    @Override
    public String toString() {
        return "MyException{" + detial + '}';
    }
}


public class Text {

    static void text(int a)throws MyException{
        if (a>10){
            throw new MyException(a);
        }
        System.out.println("ok");
    }

    public static void main(String[] args) {
        try {
            text(11);
        } catch (MyException e) {
            System.out.println("MyExpection=>"+e);
        }
    }
}

缘与风灯

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
慢慢懂的第七篇文章

Java学习day07多态动态编译，可扩展性；即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多多态存在的条件有继承关系子类重写父类方法父类引用指向子类对象多态注意事项:多态是方法的多态，属性没有多态父类和子类，有联系类型转换异常! ClassCastException !存在条件: 继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son(); .
复制链接

扫一扫