JavaSE-04之继承，多态，抽象，接口，异常

lingdu6633

已于 2022-05-14 13:22:55 修改

阅读量137

点赞数

分类专栏： JavaSE 文章标签： java

于 2022-03-28 14:18:16 首次发布

本文链接：https://blog.csdn.net/lingdu6633/article/details/123793458

版权

JavaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

继承：可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

public class student_01 extends student

student 是父类也称为超类，基类，

另一个是子类，也被成为派生类

继承中子类的特点：子类可以有父类的内容

子类还可以有自己的内容。

继承的好处和弊端：

好处：提高了代码的复用性，（多个类相同的成员可以放到统一各类中

提高了代码的维护性（如果方法需要修改，修改一处就可以了

弊端：继承让类与类之间产生了关系，类的耦合性增强了，当父类发生改变时，子类不得不

跟着变化，削弱了，子类的独立性。

继承中变量的访问的特点

在子类方法中访问一个变量，

子类局部范围找，

子类成员范围找

父类成员范围找

如果没有就报错（不考虑父亲的父亲）

如果子类方法中有变量 age，子类成员中也有，

父类成员中也有

直接访问是 age，

子类成员访问;this age

父类访问是：super.age

继承中成员方法的访问特点

成员方法：public void show(){

成员方法用对象调用

先在子类中找，之后在父类中找

构造方法的访问

子类中所有的构造方法都默认的要访问父类中无参的构造方法

为什么？

因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，

一定要先完成父类数据的初始化

每一个子类的构造方法的第一条语句都默认是：super();

如果父类中没有无参构造方法，只有带参构造方法，那就通过super关键字去调用父类的带参构造方法

推荐：自己在父类中给出一个无参构造方法

方法重写注意事项：

私有方法不能被重写（父类私有成员子类是不能继承的）

子类方法访问权限不能更低（public》默认》私有）

权限修饰符

private ：同一个类中

默认的（static ）：同一个类中，同一个包中子类无关类

protected：同一个类中，同一个包中子类无关类，不同包的子类

public：同一个类中，同一个包中子类无关类，不同包的子类，不同包的无关类

状态修饰符final 最终态

final关键字就是最终的意思，可以修饰成员方法，成员变量，类

final修饰的特点：

修饰方法：表明该方法是最终方法，不能被重写

修饰变量：该变量是常量，不能被再次赋值

修饰类：该类是最终类，不能被继承

final修饰局部变量

变量是基本类型：final修饰的数据值不能变

变量是引用类型：引用类型的地址值不能发生改变，但是地址里面的内容可以发生改变

static：是静态的意思，可以修饰成员方法，成员变量，

static修饰的特点：被类的所有对象共享，可以通过类名调用

static访问的特点：

非静态的成员方法，

能访问静态的成员变量

能访问非静态的成员变量

能访问静态的成员方法

能访问非静态的成员方法

静态的成员方法，

能访问静态的成员变量

能访问静态的成员方法

总之就是：静态的成员方法只能访问静态的成员

------------------------------------------------------

多态：同一个对象，在不同时刻表现出来的不同形态。

多态的前提和提现：

有继承、实现关系，有方法重写

有父类引用指向子类对象。

多态中成员访问特点：

成员变量看父类

成员方法看子类

因为成员方法有重写，而成员变量没有

注意：父类创建子类对象的时候，调用的方法和变量必须是父类中存在的，或者是子类中中重写的，如果直接调用子类中的变量或者方法会报错。

多态的好处和弊端：

好处：提高了程序的扩展性，

具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

多态的弊端：不能使用子类的特有功能。

多态中的转型：

向上转型

从子到父

父类引用指向子类对象

向下转型：

从父到子

父类引用转为子类对象。

-----------------------------------

抽象类：在java中一个没有方法体的方法应该定义为抽象方法，而一个类中如果有抽象方法，该类必须是抽象类。

抽象类特点

抽象类和抽象方法必须用abstract关键字修饰

抽象类中不一定有抽象方法，但是有抽象方法的一定是抽象类

抽象类不能实例化，如何实例化？参照多态的方式，通过子类对象实例化，这叫抽象类多态

抽象类的子类：要么重写抽象类中的所有抽象方法，要么是抽象类

抽象类的成员特点

成员变量：可以是变量

也可以是常量

构造方法：

有构造方法，但是不能实例化

那么构造方法的作用是什么呢？用于子类访问父类数据的初始化

成员方法：可以有抽象方法：限定子类必须完成某些动作

也可以有非抽象方法：提高代码复用性.

---------------------------------------------------------------

接口：

就是一种公共的规范标准，只要符合规范标准，大家都可以用

java中的接口更多的体现在对行为的抽象.

接口的特点：

接口用关键字interface修饰

public interface 接口名{}

类实现接口用implements 接口名{}

接口不能实例化：

接口如何实例化？参照多态的方式，通过实现类对象实例化，这叫接口多态。

多态的形式：具体类多态，抽象类多态，接口类多态

多态的前提：有继承或者实现关系，有方法重写，有（父类/接口）

引用指向（子/实现）类对象

接口的实现：要么重写接口中的所有抽象方法

要么是抽象类

接口的成员特点：

成员变量：只能是常量

默认修饰符：public static final

构造方法：

接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在

一个类如果没有父类，默认继承object类

成员方法：

只能是抽象方法

默认修饰符：public abstract

类和接口的关系：

类和类的关系：继承关系，只能单继承，但是可以多层继承

类和接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口和接口的关系：继承关系，可以单继承，也可以多继承

------------------------------------------------------------

常用api之math：

public class mathd {
    public static void main(String[] args) {
        System.out.println(Math.abs(-55));
        System.out.println("---");
        System.out.println(Math.ceil(12.11));
        System.out.println("------------");
        System.out.println(Math.floor(12.14));
        System.out.println("-------------");
        System.out.println(Math.round(89.98));
        System.out.println("---------------");
        System.out.println(Math.max(12, 34));
        System.out.println("------------");
        System.out.println(Math.pow(2, 3));
        System.out.println("------------");
        System.out.println(Math.random());
        System.out.println(Math.random() * 10);

    }
}

-----------------------------------------

---------------------------------------------

Object类：

* 是层次结构的根，每个类都可以将object作为超类，所有的类都直接或者简介的继承、

* 该类，

* 构造方法：public object（）

* 为什么子类的构造方法访问的都是父类的无参构造方法

* 因为他们的顶级父类只有无参构造方法

* 看方法源码：选中方法，CTRL+B

* tostring():自动继承，建议所有类重写这个方法

* equals方法也需要重写，可以快速生成，比较对象是否相等，重写可以比较内容

----------------------

冒泡排序：

import java.util.Arrays;

public class mathd {
    public static void main(String[] args) {
        int[] arr = {12, 85,99,34, 55, 66};
        System.out.println("排序前" + arr11(arr));
        for (int a = 0; a < arr.length - 1; a++) {
            for (int b = 0; b < arr.length - 1 - a; b++) {
                if (arr[b] > arr[b + 1]) {
                    int nn = arr[b];
                    arr[b] = arr[b + 1];
                    arr[b + 1] = nn;
                }
            }
        }
        System.out.println("排序号铺是" + arr11(arr));

    }

    public static String arr11(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int a = 0; a < arr.length; a++) {
            if (a == arr.length - 1) {
                sb.append(arr[a]);
            } else {
                sb.append(arr[a]).append(",");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

import java.util.Arrays;

public class Arrays01 {
    public static void main(String[] args) {
        int[] arr={12,23,58,49};
        System.out.println("排序前"+Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后"+Arrays.toString(arr));
    }
}

------------------------------------

基本类型包装类：将基本数据类型分装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

* 常用的操作就是：用于基本数据类型和字符串之间的转换

package com.it03;

public class Integer02 {
    public static void main(String[] args) {
       //int--string
       int number=10;
       String s1=""+number;
        System.out.println(s1);

        String s2=String.valueOf(number);
        System.out.println(s2);
        System.out.println("----");
        //string--int
        String s="100";
        Integer i=Integer.valueOf(s);
        int a=i.intValue();
        System.out.println(a);
        System.out.println("--");

        int c=Integer.parseInt(s);
        System.out.println(c);

    }
}

----------------------------

字符串中数据排序：

import java.util.Arrays;

public class Integer03 {
    public static void main(String[] args) {
        String s="91 25 46 58";
        String[] set=s.split(" ");
        int[]arr=new int[set.length];
        for(int i=0;i<set.length;i++){
            arr[i]=Integer.parseInt(set[i]);

        }
        Arrays.sort(arr);
        StringBuilder sb=new StringBuilder();
        for(int a=0;a<arr.length;a++){
            if(a==arr.length-1){
                sb.append(arr[a]);
            }else {
                sb.append(arr[a]).append(" ");
            }
        }
        System.out.println(sb);
        String   result=sb.toString();
        System.out.println("jieguo "+result);

    }
}

--------------------------------

日期类：

Date d1 = new Date();
System.out.println(d1);
System.out.println("----");
long date = 1000 * 60 * 60;
Date d2 = new Date(date);
System.out.println(d2);

Date d1 = new Date();

System.out.println(d1.getTime());

System.out.println(d1.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

System.out.println("____");

long time=System.currentTimeMillis();

d1.setTime(time);

System.out.println(d1);

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;

public class SimpleDate01 {
    public static void main(String[] args) throws ParseException {
        //date--String
      Date d=new Date();
        System.out.println(d);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s=sdf.format(d);
        System.out.println(s);
        System.out.println("----");
//string-date
String ss="2021-08-09 11:17:37";
SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd=sdf2.parse(ss);
        System.out.println(dd);
    }
}

日期工具类：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Dateutil01 {
    private Dateutil01(){

    }
    public static String datetostring(Date date, String format){
        SimpleDateFormat sdf=new SimpleDateFormat(format);
        String s=sdf.format(date);
        return s;
    }
    public static Date Stringtodate(String s,String format) throws ParseException {

        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date dd = sdf.parse(s);
        return dd;
    }
}

package com.it03.Dateutils;

import java.text.ParseException;
import java.util.Date;

public class tuiltest01 {
    public static void main(String[] args) throws ParseException {
        Date d=new Date();
        String   s1=Dateutil01.datetostring(d,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        System.out.println("-----");

        String s="2021-12-14 12:12:12";
        Date dd=Dateutil01.Stringtodate(s,"yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);
    }
}

日历类：

import java.util.Calendar;

public class Calender01 {
    public static void main(String[] args) {
        Calendar c=Calendar.getInstance();
        int y=c.get(Calendar.YEAR);
        int m=c.get(Calendar.MONTH)+1;
        int d=c.get(Calendar.DATE);
        System.out.println(y+"年"+m+"月"+d+"日");
    }
}

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;

public class arrays1 {
    public static void main(String[] args) throws ParseException {
        Calendar c1 = Calendar.getInstance();
//        // c1.add(Calendar.YEAR, -3);
//        System.out.println("-------");
//
//        c1.add(Calendar.YEAR, +10);
//        c1.add(Calendar.DATE, -5);
//        int a = c1.get(Calendar.YEAR);
//        int b = c1.get(Calendar.MONTH) + 1;
//
//        int c = c1.get(Calendar.DATE);
//        System.out.println(a + "年" + b + "月" + c + "日");

        c1.set(2048, 10, 11);
        int a = c1.get(Calendar.YEAR);
        int b = c1.get(Calendar.MONTH) + 1;
        int c = c1.get(Calendar.DATE);
        System.out.println(a + "年" + b + "月" + c + "日");
    }
}