super详解，方法重载，重写，多态，抽象，接口，异常

最新推荐文章于 2021-09-09 12:07:42 发布

十弌

最新推荐文章于 2021-09-09 12:07:42 发布

阅读量103

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/niwad/article/details/118918091

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

super详解

关于值

package super详解;

public class student   extends  person{
    private String name="yep";
    public void test (String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

package super详解;

public class person {
    protected String name="yee";
}

package super详解;

public class student   extends  person{
    private String name="yep";
    public void test (String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

关于方法

package super详解;

public class student   extends  person{

    public void  print(){
        System.out.println("student");
    }
    public void test (){
       print();
       this.print();
       super.print();
    }
}

package super详解;

public class person {
    public void print(){
        System.out.println("person");
    }
}

package super详解;

public class Application {
    public static void main(String[] args) {
        student student=new student();
        student.test();
    }
}

关于无参构造

package super详解;

public class student   extends  person{
    public student() {
        System.out.println("子类的无参构造已执行");
    }

}

package super详解;

public class person {
    public person() {
        System.out.println("父类的无参构造执行了");
    }

package super详解;

public class Application {
    public static void main(String[] args) {
        student student=new student();

    }
}

notice

私有的东西不可以被继承

package super详解;

public class student   extends  person{
  
    public student() {
      super();
        System.out.println("子类的无参构造已执行");
    }

}

其实有隐藏代码在调用子类student无参构造的时候会有super（）；

且super需要在第一行

且一个无参构造里面不能同时有super(); this();

如果将父类的无参构造写为有参构造

则在子类调用父类的时候子类根本就无法去写无参构造

如果子类要去实现自己的无参构造则需要执行super（输入值）；
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ESrtIxlU-1626711525312)(https://i.loli.net/2021/07/16/dsQ5FnEJBYourZ6.png)]

重写（override）详解

重写都是方法的重写与属性无关
非静态的方法才可以重写
其他类的写错也会导致项目部无法继续运行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KfJZDUCX-1626711525314)(https://i.loli.net/2021/07/16/pxCUIf92bMhPnVl.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P2q90ZHC-1626711525315)(/Users/eleven/Library/Application Support/typora-user-images/截屏2021-07-16 下午4.20.28.png)]

多态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lwHrL1Yw-1626711525315)(https://i.loli.net/2021/07/16/HEsvon3lbaPite4.png)]

可以用父类的引用指向子类的类型
static或者final方法不可以作为多态，因为其方法为static或者final不可以重写
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BE53sicn-1626711525316)(https://i.loli.net/2021/07/16/A8rsWbeB5tYEPNz.png)]
子类重写了父类的方法的话调用子类的方法

package 多态;

public class Application {
    public static void main(String[] args) {
        Person person = new Student();
        Student student = new Student();
        person.test();
        student.test();
    }

}
package 多态;

public class Person {
    public void test(){
        System.out.println("PersonTest");
    }
}
package 多态;

public class Student extends Person
{
    @Override
    public void test() {
        System.out.println("StudentTest");
    }
}

instanseof（类型转换类型转换）

package 多态;

import super详解.person;

public class Test {
    public static void main(String[] args) {
        person person=new person();
        System.out.println(person instanceof Object);
        System.out.println(person instanceof person);
        Student student=new Student();
        System.out.println(student instanceof Object);
        System.out.println(student instanceof Person);

    }


}

父类引用指向子类的对象
把子类转换为父类，向上转型，不用强制转换
父类转换为子类，向下转型，需要强制转换

方便方法的调用减少重复的代码

Static

package static方法详解;

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

public class Person {
    //2
    {
        System.out.println("匿名方法块");
    }

    //1
    static {
        System.out.println("静态方法块");
    }

    //3
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(random());
        System.out.println(PI);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BDj0xcPE-1626711525317)(https://i.loli.net/2021/07/17/zPYjcUqiK2eno7u.png)]

static可以通过静态导入包的方式节省调用java原方法库的过程

absract抽象类

抽象类的方法必须要重写，通过子类来实现
java类只可以单继承，接口可以多继承
抽象类可以写普通方法
抽象方法必须在抽象类之中
思考题
1. new，存在构造器吗
  
  抽象类不可以被new只可以new为它的子类向下转型
  
  抽象类存在构造器
2. 存在的意义
  
  便于高效协作开发

接口

接口即是规范。约束和实现分离：面向接口编程

接口本质是契约，是面向对象最本质的体现

接口关键字为interface类的关键字为class

接口都需要实现类，类可以实现接口

实现接口的类就需要重写接口中的方法

接口可以实现多继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FbL4W0a1-1626711525318)(https://i.loli.net/2021/07/17/VAoCXx9RnWbe8gI.png)]

接口定义的属性也可以

接口的作用：

约束
定义一些方法让不同人实现
Pubic abstract
Public static final
接口不能被实例化
接口中没有构造方法
implements可以实现多个接口
必须重写接口的方法

内部类

一个类里边再定义一个类

内部类可以获得外部类的私有属性和私有方法

成员内部类
静态内部类
局部内部类
匿名内部类

异常机制

什么是异常

运行中出现的问题error

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RN7mhiyh-1626711525318)(…/Library/Application Support/typora-user-images/截屏2021-07-17 下午4.41.03.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w33ko8Lu-1626711525319)(https://i.loli.net/2021/07/17/UJRutFKCnWPhvVH.png)]

异常处理机制

try监控区域
catch捕获异常
throw抛出异常
finally处理善后工作
throws

command+option+T自动生成方法

package 异常;

public class Test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {//try监控区域
            System.out.println(a/b);
        }catch (Throwable){//catch捕获异常括号里面是想要捕获的异常类型常见异常如下图
            System.out.println("程序出现异常，被除数不可以为0");
        }finally {//处理善后工作
            System.out.println("finally");
        }

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qYv8oVpx-1626711525320)(https://i.loli.net/2021/07/17/q46XeaZCcMFRkpx.png)]

throw与throws

主动抛出一个异常

throws:
跟在方法声明后面，后面跟的是异常类名
throws:
可以跟多个异常类名，用逗号隔开
throws:
表示抛出异常，由该方法的调用者来处理
throw:
用在方法体内，后面跟的是异常类对象名
throw:
只能抛出一个异常对象名
throw:
表示抛出异常，由该方法体内的语句来处理

自定义异常

package 异常;

public class MyException extends Exception{
    //传递数字>10
    private  int detail;
    public MyException(int a){
        this.detail=a;
    }

    @Override
    public String toString() {
        return"MyException{"+detail+"}";
    }
}

package 异常;

public class Application {
    //可能会存在异常的方法
    static void application(int a) throws MyException{
        System.out.println("传递的参数为："+a);
        if (a>10){
            throw  new MyException(a);
        }
        System.out.println("OK");

    }

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

十弌

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
super详解，方法重载，重写，多态，抽象，接口，异常

super详解关于值package super详解;public class student extends person{ private String name="yep"; public void test (String name){ System.out.println(name); System.out.println(this.name); System.out.println(super.name); }
复制链接

扫一扫