Day07

最新推荐文章于 2024-06-07 00:18:48 发布

eternal_20

最新推荐文章于 2024-06-07 00:18:48 发布

阅读量126

点赞数

本文链接：https://blog.csdn.net/eternal_20/article/details/123388375

版权

instance of (类型转换) 引用类型

//System.out.println(x instanceof y);能不能编译通过看他们存不存在父子关系

1.父类引用指向子类对象（对象的上转型对象）

2.把子类引用转化为父类（上转）

3.把父类引用转化为子类（下转）（强制转换）

4.方便方法调用

强制转换让对象的上转型对象能使用子类新增方法。

final类没有子类

public class Application {
    public static void main(String[] args) {
//       Object object = new Student();

        //System.out.println(x instanceof  y);能不能编译通过看他们存不存在父子关系
//        System.out.println(object instanceof Student);//true
//        System.out.println(object instanceof Person);//true
//        System.out.println(object instanceof Object);//true
//        System.out.println(object instanceof Teacher);//false
//          System.out.println(object instanceof String);//false


        //类型转换  ：  父    子
        //高                低
        Person dc = new Student();
        dc.sleep();
        //dc.go();是调用不了的
        //将dc这个对象转化为Student类型，我们就能调用Student的方法了
        Student dc1 = (Student) dc;
        ((Student) dc).go();// = dc1.go();
        //子类转化为父类可能丢失一些方法
        Student student = new Student();
        Person person = student;
        student.go();
       //person.go();报错
        //就是student相当与dc1
        //person相当于dc

//都是run1因为被重写了
        dc1.run();
        dc.run();
        student.run();
        person.run();



    }
}

public class Person {
    public void run(){
        System.out.println("run");
    }
    public void  sleep(){
        System.out.println("sleep");
    }
}

public class Student extends Person {
public void go(){
    System.out.println("go");
}
    public void run(){
        System.out.println("run1");
    }

}

{...}//匿名代码块-----可以赋初值

{...}//静态代码块----只执行一次

public class Person {
    {
        //匿名代码块 可以赋初始值
        System.out.println("匿名代码块");
    }
    static {
        //静态代码块    只执行一次
        System.out.println("静态代码块");
    }

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

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("===============");
        Person person2 = new Person();
    }
}

先运行静态代码块之后匿名代码块再之后构造方法

static

静态变量：随时可调用

非静态变量：创建对象实例化才能调用

静态方法和非静态都可以调用静态方法

但是静态方法不能调用非静态方法

//static的使用
public class Student {
    public static  int age; //静态变量
    private  double score;  //非静态变量
//静态方法和非静态都可以调用静态方法
    //但是静态方法不能调用非静态方法
    public void run(){
     Student.sleep();
    }
    public static void sleep(){

    }
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);  //可以直接用类去调用静态变量
        System.out.println(s1.score);
        System.out.println(s1.age);
    }
}

静态导入包

//静态导入包
import static java.lang.Math.PI;
import static  java.lang.Math.random;
public class Application {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

抽象类所有方法，继承了他的子类，都必须要实现他的方法（或者子类的子类）

抽象类 abstract extends: 单继承（接口多继承）

抽象方法：只有方法名字没有方法实现

//抽象类  abstract   extends: 单继承    （接口多继承）
public abstract class  Action {
    //约束~有人帮我们实现
    //abstract  ,抽象方法只有方法名字没有方法实现
  public abstract void doSomething();
  //1.不能new 这个抽象类，只能靠子类继承 ：：约束

}

//抽象类所有方法，继承了他的子类，都必须要实现他的方法
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

1.不能new这个抽象类

2.抽象类可以写普通方法

3.抽象方法必须在抽象类中

接口

普通类：只有具体实现

抽象类：有具体实现和规范

接口：只有规范 ---自己无法写方法约束

接口本质是契约

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

//抽象类
//类可以实现接口  implement
//实现接口的类就必须重写接口方法
//多继承 ---利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void updata(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}

//抽象的思维
//interface 定义的关键字   接口都需要实现类
public interface UserService {

    //常量---public static final
      int age = 99;


    //接口中的所有定义都是抽象的  public
    //
//    public abstract void run();
    void  add(String name);
    void  delete(String name);
    void  updata(String name);
    void  query(String name);
}

1.约束

2.定义一个方法，让不同人实现

3.public abstract (默认)

4.public static final （默认）

5.接口不能实例化，接口没有构造函数

6.必须要重写接口方法

内部类

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //outer.new Inner();
        Outer.Inner inner = outer.new Inner();
inner.in();
inner.getId();
    }
}

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("外部类方法");
    }
    class Inner{
        public void in(){
            System.out.println("内部类方法");

        }
        public void getId(){
            //套娃方法里也能写内部类

            System.out.println(id);
            out();
        }
    }
}

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

}

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用把实例保存到变量中
       new Apple().eat();

    }

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

interface UserService{
    void hello();
}

内部类用.实例化例如：Outer.Inner inner = outer.new Inner();

一个java类中可以有多个class类，但是只有一个public class

方法里也能写内部类

内部类可以直接调用外部类方法

异常

Error类异常对象大多数由虚拟机抛出错误与编写者执行的操作无关。

Exception重要子类RuntimeException（运行异常）

异常处理：抛出异常捕获异常

异常处理关键字：

try, catch ,finally ,throw ,throws

捕获多个异常要从小到大捕获

try{...}

catch(小){...}

catch（中）{...}

catch（大）{...}

finally{...} //会执行一次

public class Test2 {
    public static void main(String[] args) {
//        int a = 1;
//        int b = 0;
        //Ctrl + Alt +T
//
//        try {
//            System.out.println(a/b);
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//        }



        //try catch 可以让异常不停止继续往下走
        try {
            new Test2().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }

    }
    //假设这个方法处理不了，那么在方法中抛出异常
    public void  test(int a,int b) throws ArithmeticException{

        if (b==0){
            throw new ArithmeticException();//主动抛出异常
        }
        System.out.println(a/b);
    }
}

public class Test {
    public static void main(String[] args) {
           int a = 1;
        int b = 0;

try {//try 监控区域

    if (b==0){
        throw new ArithmeticException();//主动抛出异常
    }


    System.out.println(a/b);

}catch (Error e ){//catch(想要捕获的异常类型) 捕获异常
    System.out.println("Error");

}catch (Exception e){
    System.out.println("Exception");

}catch (Throwable e){
    System.out.println("Throwable");

}

finally {//处理善后工作
    System.out.println("finally");
}

        //try catch 可以让异常不停止继续往下走
        try {
            new Test().a();
        } catch (Error e) {
            System.out.println("a异常");
        }


//fianlly 可以不要  ，假设有IO资源可以关闭
    }
public void a(){
        b();
}
public void b(){
        a();
}



}

Ctrl + Alt +T