Java基础，精心准备，分享出来，与君共进--------(封装继承多态抽象接口异常)

C_x_330

已于 2022-04-20 23:07:40 修改

阅读量2.7k

点赞数 5

分类专栏： java基础文章标签： java

于 2022-04-19 20:53:41 首次发布

本文链接：https://blog.csdn.net/C_x_330/article/details/124282889

版权

java基础专栏收录该内容

40 篇文章 0 订阅

订阅专栏

立身以立学为先，立学以读书为本

文章目录

封装

封装大多是针对属性来说的，方法用不了多少封装
属性私有(private),get/set
“高内聚，低耦合”
1. 高内聚:类的内部数据操作细节自己完成，不允许外部干涉
2. 低耦合:仅暴露少量的方法给外部使用
封装的意义
1. 提高程序的安全性，保护数据
2. 隐藏代码的细节实现
3. 统一接口
4. 系统的可维护增加了

继承

extends (扩展)。子类是父类的扩展
java中类只有单继承，没有多继承 (一个儿子只能有一个爹爹，一个爸爸可以有多个儿子)
java中类只有单继承没有多继承，但是接口可以多继承
基类(父类) --> 派生类(子类)
继承是**类和类之间的一种关系**，除此之外,类和类之间还有:依赖组合聚合关系
如果父类属性的修饰符是public,那么子类就可以继承父类的所有属性和方法
常见的4个修饰符
1. public
2. protected
3. default
4. private

被final定义的类不能被继承

public final class Person()
//如果一个类被final 定义了 则这个类就不能被继承(这个类就没有儿子)

super的注意点

super调用父类的构造方法，必须在构造方法的第一个
super必须且只能出现在子类的方法或构造方法中
super和this不能同时调用构造方法

super VS this
1. 代表的对象不同
  - thiis. 本身调用者这个对象
  - super. 代表父类对象的引用
2. 前提
  - this. 没有继承也可以使用
  - super. 只有在继承的条件下才可以使用
3. 构造方法
  - 本类的构造
  - 父类的构造
在java中，所有的类都默认直接或者间接继承object类
在子类和父类都有无参构造的前提下，先调用父类的无参构造后调用子类的无参构造
如果父类写的是有参构造，那么你如果在子类写无参构造就会报错，但是如果你在子类的无参构造里用super()去调用父类的有参构造的话，就不会报错

方法的重写

重写都是方法的重写，和属性无关
重写跟静态方法没有任何关系，和非静态方法有关！
重写的条件
1. 方法必须是**非静态**的方法
2. 关键词必须是public
只有子类继承了父类才能重写，并且是子类重写父类的方法
如果子类重写了父类的方法，父类执行子类的方法
子类能调用的方法都是自己的或者继承父类的
父类型可以指向子类，但是不能调用子类独有的方法

多态

同一方法可以根据发送对象的不同而采取多种不同的行为方式
一个对象的实际类型是确定的但可以指向对象的引用类型(父类或有关系的类)有很多
多态存在的条件
1. 存在继承关系
2. 子类重写父类的方法
3. 父类引用指向子类对象
多态是方法的多态，属性没有多态性
instanceof
1. (类型转换) 引用类型
2. 判断一个对象是什么类型

//instanceof 的使用方法
//   对象 instanceof 父类
//   对象 instanceof 子类

父子之间转换

父类引用指向子类的对象
把子类转换为父类底向高转换不用强转
把父类转换为子类高向低转换需要强转

static

静态代码块，在程序运行的时候仅执行一次，匿名代码块在每次new对象的时候都会执行，构造函数也是在每次new对象的时候都会执行

public class Student extends Person {

    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }

    public Student() {
        System.out.println("构造函数");
    }

    public static void main(String[] args) {
        Student student=new Student();
        System.out.println("#####################################");
        Student student1=new Student();

    }
}

//输出结果:
静态代码块
匿名代码块
构造函数
#####################################
匿名代码块
构造函数

抽象类

//使用方法
public abstract class Action(){
    //只有方法的名字 没有方法的实现
	public abstract void test();
}
//在一个类的定义中加一个abstract就变成了抽象类c

抽象方法

//抽象类的所有方法，继承了它的子类  都必须要实现它的方法 除非这个继承的子类也是一个抽象类，那么则必须由子类的子类去实现
public class A extends Action(){
    @Override  //重写
	public A{
        super();
    }
    //如果继承的这个子类不是抽象类，并且没有重写，则在main()中即使你   
    //   A a=new A();   在运行的时候会报错误
}

特点
1. 不能new这个抽象类，只能靠子类去实现它，存在约束！
2. 一个抽象类里面可以没有抽象方法，但是如果一个类里面有抽象方法则这个类一定是一个抽象类
3. 抽象类虽然不能有new实例化，但还是存在构造器
抽象类对于代码的维护和重用具有很好的帮助

接口

声明类 class 声明接口 interface
普通类：只有具体实现
抽象类：具体实现和规范(抽象方法)都有
接口：只有规范，自己无法写方法，专业的抽象！抽象的抽象！约束和实现分离，面向接口编程！
接口就是规范，定义好一组规则，”假如你是…则必须…“的思想
接口的本质是契约,就像我们人间方法，指定好之后我们都要遵守

public interface UserService {

    //接口中不允许写具体的方法 只允许写接口的声明！！！
    //接口中所有的定义其实都是public abstract
    //我们平时在写的时候可以只写函数声明(函数的返回值  函数名  函数的参数)
    //系统默认定义它为public abstract
	//接口中都是函数的声明，我们需要实现类去实现接口中定义的函数  
    //实现类名字后面一般加上(Impl)
    
    
    //接口中属性的定义默认类型为  public static final
    public static final int AGE=35;
    double MONEY=100.5;
    
    
    public abstract void run();
    void rrun();
}

public interface TimeService(){
    void timer();
}
    //普通的类可以通过 implements+接口名字  实现对接接口
    //实现了接口中的类，就必须重写接口中的方法
    public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {
		
    }
        
    @override 
    public void timer(){}
}

接口不可以被实例化，接口中没有构造
通过 implements 可以实现多个接口
如果一个类对接了接口则必须重写接口中的函数定义

内部类

在一个类的内部在定义一个类；比如:在A类中定义一个B类，那么B类相对A类来说就是一个内部类，A类相对B类来说就是一个外部类
内部类的分类
1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类
可以获得外部类的属性，私有属性，方法
一个java类中可以有多个class类，但只能有一个 public class 类

//如何使用创建内部类
public class  MainApplication {
    public static void main(String[] args) {
        
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceImpl.Inter inter = userService.new Inter();
        inter.run();
    }
}
//-----------------------------------------------------------------------
public class UserServiceImpl {
        private int id;
        public int  age;

        public void set(){
            System.out.println("这时外部类");
        }
        public class Inter{
            public void run(){
                System.out.println("这是内部类");
            }
        }
}

不同内部类的实现

public class UserServiceImpl {
        private int id;
        public int  age;

        public void set(){

            System.out.println("这时外部类");

            //局部内部类  在某个类的方法中在定义一个类
            class Inter_2{
                public void run_2(){
                    System.out.println("局部内部类");
                }
            }
        }

        //静态内部类  static
        public static class Inter_2{
            public void run_3(){
                System.out.println("这是静态内部类");
            }
        }

        //成员内部类
        public class Inter{
            public void run(){
                System.out.println("这是内部类");
            }
        }

    public static void main(String[] args) {
        //没有名字的初始化类，不用将实例保存到变量中   匿名内部类
        new  Apple().name();
    }
}

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

异常机制 Exception

大致分类
1. 检查时异常（程序员无法预见,用户错误或问题引起的异常 Fg:打开一个不错在的文件）
2. 运行时异常（可能在编译时被忽略 Fg:10/0）
3. 错误(在代码中通常被忽略，Fg:栈溢出一旦错误发生，它们在编译时也检查不到)
Java把异常作为对象来处理，并定义了一个基类 java.lang.Throwable 作为所有异常的超类

在这里插入图片描述

ERROE通常是灾难性的致命错误，是程序无法控制和处理的，当这些错误( OutOfMemoryError )出现时，Java虚拟机(JVM)一般会终止线程( Virtual MachineError )。Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能去处理这些异常
虚拟机试图执行应用时可能发生的在程序员控制和处理能力之外的错误:
1. 类定义错误 ( NOClassDefFoundError )
2. 链接错误( LinkageError )
Exception分支中有一个重要的子类 RuntimeException(运行时异常)
1. ArrayIndexOutOfBoundsException (数组下标越界)
2. NullPointerException (空指针异常)
3. ArithmeticException (算术异常)
4. MissResourceException (丢失资源)
5. ClassNotFoundException （找不到类）
  - 这些异常是不检查异常长序中可以选择捕获处理，也可以不处理
  - 一般由程序逻辑引起的错误

异常处理机制

抛出异常
捕获异常
异常处理的五个关键字
1. try
2. catch
3. finally
4. throw
5. throws
一个快捷键: Ctrl Alt t 可以自己选择想要异常处理的形式

//try catch final 基本使用方法

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

        try {//try 监控区域
            System.out.println(1/0);
        } catch (ArithmeticException e) {// catch捕获异常
            System.out.println("ArithmeticException");
            System.out.println("分母不能为0");
            e.printStackTrace();//自动打印错误的栈的信息
        } catch (Exception e){
            System.out.println("Exception");
        }finally {//处理善后工作
            System.out.println("Final");
        }
    }
    //注意：catch可以多次使用，但是catch包含异常的层级必须是从低到高的，假如我把上面的两个catch互换位       置的话，就会报错，因为Exception包含了ArithmeticException
}


//throw  && throws 简单使用方法
public class  MainApplication {
    public static void main(String[] args) {


            new MainApplication().test(1,0);
    }
    
    // 假设这个方法中 处理不了这个异常 方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){
            throw  new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
    }
}