8-4 day08

最新推荐文章于 2024-01-16 21:42:57 发布

云柏田

最新推荐文章于 2024-01-16 21:42:57 发布

阅读量79

点赞数

本文链接：https://blog.csdn.net/wumingxiaoi/article/details/119397528

版权

super注意点:

.super调用父类的构造器的时候，必须在构造方法的第一个。
.super只能出现在子类的方法或者构造方法中！
super 和this不能同时调用构造方法!

super 和 this:

代表的对象不同：

this: 本身调用者这个对象

super:代表父类对象的应用

前提：

this:没有继承也可以使用

super：只能在继承条件时才可以使用

构造方法：

this():本类的构造

super():父类的构造！

方法的重写

重写是方法的重写，与属性无关。

方法重写需要满足的条件

需要有继承关系
子类重写父类的方法
方法名必须相同，参数列表需要相同
修饰符，范围可以扩大但是并不能缩小
抛出的一次可以缩小但是不能扩大

快捷键

Alt + insert -> Override

多态：

即同一个的方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件

有继承关系
子类重写父类的方法
父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

instanceof

多态注意事项

多态是方法的多态，属性没有多态
类型转换异常 ClassCastException!

//对象能执行哪些方法取决于引用类型
//执行什么哪个方法,取决于对象

不能被重写的方法

static 方法属于类，不属于实例
final 常量
private 私有的

instanceof （类型转换）引用类型

instanceof 关键字可以用来判断两个类是否为父子关系

抽象类

abstract修饰符可以用用来修饰方法也可以修饰类

如果修饰方法，那么该方法就是抽象方法；如果修饰类，就是抽象类

抽象类里可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

抽象类：不能使用new关键字来创建对象，它是用来让子类继承的

抽象方法：只有方法的声明，没有方法的实现，它是用来让子类实现的

子类继承抽象类，那么必须要实现抽象类没有实现的抽象方法，否则子类也要声明为抽象类

抽象类的特点：

首先是一个类
里面是抽象方法
方法的实现交给子类实现，有点像是蚁后
抽象类是不能new的
抽象的类里可以写不抽象的方法
抽象的方法一样要写在抽象类里

java接口

普通类：只有具体实现

抽象类：具体实现和抽象方法都有

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

接口就是规范，定义的是一组规则，体现了在现实世界中“如果你是…则必须能…”的思想。如果你是天使，就必须能飞。

如果你是汽车，就必须能跑，如果你是好人，就必须干掉坏人，如果你是坏人，就必须欺负好人，

接口的本质是契约，就行我们人间的法律一样，制定好之后大家都必须遵守

OO的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式只针对具备了抽象能力的语言（比如C++，java,c#等），就是因为设计模式所研究的就是，合理的去抽象

声明类的关键字是calss,声明接口的关键字是interface

接口的作用：

约束
定义一些方法，让不同的人来实现
接口默认的方法是public static的
接口中默认的常量是 public static final的
接口是不能被实例化的，因为没有构造方法
可以实现多继承

内部类

内部类就是在一个类的内部定义一个类

比如，A类中定义一个B类，那么B类就是A类的内部类，A类就是B类的外部内了

内部类还分为：

成员内部类就是类中的类
静态内部类就是类中的静态类
局部内部类就是方法中的类
匿名内部类就是没有名字的去初始化类

异常机制：

关键字：Exception

异常是指程序运行中出现的不期而遇的各种状况：

比如：文件找不到，网络连接失败，非法参数等

三大异常：

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。

例如：要打开一个不存在的文件时，一个异常就发生了，这些异常在编译的时候不能简单的被忽略
运行时异常：运行时异常可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误（error）：错误不是异常，而是脱离程序员控制的问题，错误在代码中通常被忽略。例如，当栈溢出的时候，一个错误就发生了，错误在编译的时候是jvm是检查不到的。

java异常处理框架：

在java中，已经定义了很多的异常，这些异常分为两大类：

异常Exception
错误Error

Error

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

java虚拟机运行错误（Virtual MachineError）

当jvm不再继续执行操作所需的内存资源时，将出现OutOfMenoryError。

这些异常发生时，java虚拟机（jvm）一般会选择线程终止

还有发生在虚拟机试图执行应用时，如定义错误（NoClassDefoundError）,链接错误（LinkageError）.

这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

Exception

在Exception中有一个重要的子类RuntimeException（运行时异常）

ArrayIndexOutOfBoundException（数组下标越界）
NullpointerException（空指针异常）
ArithmeticException（算数异常）
MissingResoureException （丢失资源）
ClassNotFoundException （找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理

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

Error和Exception的区别：

Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，java虚拟机（JVM）一般会选择终止线程。

Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

Exception的抛出和捕获

异常处理的5个关键字

try
catch
finally
throw
throws

可以捕获多个异常，从小到大排序，因为先捕获大的异常，小的异常就不会执行了

快捷键

ctrl + alt + t

自定义异常

使用java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。

用户自定义异常，只需要继承Excetyion类即可。

package day08.AbstractDemo;


//使用abctract 修饰类，类就变成了抽象方法
public abstract class Action {

    //抽象方法，用abstract来修饰方法，就变成了抽象方法
    public abstract void doSomething();
}

package day08.AbstractDemo;

//如果子类也是抽象类的话，可以不用实现方法
//抽象类，还是一个类，类的话是单继承的，没有办法继承多个类
//但是java里有一个东西叫接口，可以实现多继承
public class A extends Action {
    @Override
    public void doSomething() {
        System.out.println("放空!");
    }

    public static void main(String[] args) {
        //new Action();//'Action' is abstract; cannot be instantiated
    }
}

package day08.Demo01;

public class Application {
    public static void main(String[] args) {

        //外部类
        Outer outer = new Outer();

        //通过这个外部类来实例化内部类
         //Outer.Inner inner = outer.new Inner();
         //inner.in();
         //System.out.println(inner.getId());
    }
}

package day08.Demo01;

public class Outer {

    private int id;
    public void out(){
        System.out.println("这是外部类的方法！");
    }

    public void megthod(){
        //局部内部类，写在方法里的类
        class Inner{

        }
    }

    static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //内部类可以直接访问到外部类的私有属性和私有方法
        //当内部类为静态的时候，访问不到外部类的私有方法和属性
        public void getId(){
        //   System.out.println(id);
        }
    }
}

//一个java类中可以有多个class类，但是只能有一个public的
class A{

}

package day08.Demo02;

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();

        //匿名内部类 就是没有名字去初始化类
        new Apple().eat();
        new UserService(){
            @Override
            public void hello() {
                System.out.println("hello");
            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

package day08.Demo03;

public class Test {
    public static void main(String[] args) {

        new Test().test(2, 0);

        int a = 1;
        int b = 0;

        try {
            System.out.println(a/ b);
        }catch (ArithmeticException e){//捕获异常
           e.printStackTrace();//打印栈信息
        }
        //finally一般用来关闭流
        finally {//处理后续工作
            System.out.println("finally");
        }
    }

    //如果这个方法处理不了这个异常，可以向上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b == 0) {
            throw new ArithmeticException();//一般在方法里使用
        }
    }
}

package day08.ExceptionDemo;

public class MyException extends Exception {

    //传递数字 > 10
    private int detail;

    public MyException(int a) {
       detail = a;
    }

    //toString:异常的打印信息

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

package day08.ExceptionDemo;

public class Demo01 {
    public static void main(String[] args) {
//        new Demo01().a();//Exception in thread "main" java.lang.StackOverflowError
//        System.out.println(10 /0);//Exception in thread "main" java.lang.ArithmeticException: / by zero

    }

    public void a(){
        b();
    }

    public void b(){
        a();
    }
}

package day08.ExceptionDemo;

public class Test {
    //可能会存在异常的方法

    static void test(int a){
        System.out.println(a);
        if (a > 10){
            try {
                throw new MyException(a);
            } catch (MyException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        test(11);
    }
}

package day08.InterfaceDemo;

public interface TimeService {
    void timer();
}

package day08.InterfaceDemo;

//接口都需要有一个实现类
public interface UserService {

   //接口中的常量 默认是 public static final
   public static final int age = 99;

    //接口中所有的定义都是抽象的，而且都是Public的
    //所以在接口中写，可以直接写返回值类型 和方法名；
   public abstract void run();

   //增
   void add(String name);
   //删
   void delate(String name);
   //改
   void update(String name);
   //查
   void query(String name);



}

package day08.InterfaceDemo;

//实现了接口，必须实现方法

//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void run() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delate(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

package day08;

public class A {

    public void sleep(){
        System.out.println("A睡着了！");
    }
}

package day08;

public class B  extends A{

    public void sleep() {
        System.out.println("B睡着了！");
    }
}

package day08;

public class Persion {

    public void run(){
        System.out.println("奔跑！");
    }
}

package day08;

public class Student extends Persion {

    @Override
    public void run() {
        System.out.println("小跑");
    }
}

package day08;

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.sleep();

        //父类可以指向子类
        A a1 = new B();
        a1.sleep();//重写的方法的调用和new的对象有关

        //子类指向父类会报错
        //B b = new A();

        //一个对象的类型是确定的
        //new Student（）;
        //new Persion（）;

        //但是引用类型是不确定的

        Student s1 = new Student();

        Persion persion = s1;//低转高，自动转换

        //父类的引用类型指向子类对象
        Persion s2 = new Student();

        Student s21 = (Student)s2;//高转低，强制转换

        Object s3 = new Student();

        //对象能执行哪些方法取决于引用类型
        //执行什么哪个方法,取决于对象
        s1.run();
        s2.run();

        System.out.println(s1 instanceof Persion );//判断是否有父子关系
    }
}

云柏田

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
8-4 day08

super注意点:.super调用父类的构造器的时候，必须在构造方法的第一个。.super只能出现在子类的方法或者构造方法中！super 和this不能同时调用构造方法!super 和 this:代表的对象不同： this: 本身调用者这个对象 super:代表父类对象的应用前提： this:没有继承也可以使用 super：只能在继承条件时才可以使用构造方法： this():本类的构造 super():父类的构造！方法的重写重写是方法的重写，与属性无关。.
复制链接

扫一扫