Java学习第三十四天＜Final＞＜抽象类＞＜接口入门＞＜接口与继承对比＞＜接口数组＞＜接口多态＞

于 2022-03-26 18:55:09 发布
阅读量333 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/syd2820/article/details/123761204
版权

Final

package chapter10.D4关键字Final;
//final最后的，用在类则不能被继承（但可实例化），用在方法则不能被重写（可在子类继承），用在属性上则不能修改
//用作常量，必须赋值（定义时，构造器赋值，代码块赋值） 若是静态常量，不能用构造器赋值，因为加载顺序有先后
//final用在类上（希望不被继承），则没必要将方法也final（希望不被重写，继承不了当然重写不了）
//final与static常一起用，不会导致类加载
//String 和包装类（Double,Float,Integer,Boolean）都是final类，不能继承
public class Final {
    public static void main(String[] args) {
        System.out.println(B02.num);
    }
}
class B02{
    public final static int num=1000;
    static {
        System.out.println("BBB代码块执行");
    }
}

package chapter10.D4关键字Final;
​
public class Fnialexercise {
    public static void main(String[] args) {
        Circle circle = new Circle(5.0);
        System.out.println(circle.calArea());
​
    }
}
class Circle{
    private double radius;
    private final  double PI;//可直接赋值
​
    public Circle(double radius) {
        this.radius = radius;
        //PI=3.14;构造器里赋值
    }
​
    {
        PI=3.14;//代码块里赋值
    }
    public double calArea(){
        return PI*radius*radius;
    }
}

抽象类

package chapter10.D5抽象类;
//没有方法体，方法和类都要戴abstract，抽象类不能实例化，由子类继承实现
//abstract不能修饰属性和其他
//抽象方法不能使用private、final和static修饰 这些关键字和重写相违背（private不能重写，final不能被继承重写，static与重写无关）
public class Abstract01 {
    public static void main(String[] args) {
        new CommonEmployee("xx",1,200).work();
        new Manager("yy",2,300,1000).work();
    }
​
}
abstract class Employee{
   private String name;
   private int ID;
   private double salary;
​
    public Employee(String name, int ID, double salary) {
        this.name = name;
        this.ID = ID;
        this.salary = salary;
    }
​
    public String getName() {
        return name;
    }
​
    public int getID() {
        return ID;
    }
​
    public double getSalary() {
        return salary;
    }
​
    abstract public void work();
}
class CommonEmployee extends Employee{
    public CommonEmployee(String name, int ID, double salary) {
        super(name, ID, salary);
    }
​
    @Override
    public void work() {
        System.out.println("普通员工\t"+getName()+"\t工作中");
    }
}
class Manager extends Employee{
    private double bonus;
​
    public Manager(String name, int ID, double salary, double bonus) {
        super(name, ID, salary);
        this.bonus = bonus;
    }
​
    @Override
    public void work() {
        System.out.println("经理\t"+getName()+"\t工作中");
    }
}

package chapter10.D5抽象类;
//抽象类，模板设计模式
abstract public class Template {
    public abstract void job();
    public void calc(){//可做成模板
        long start=System.currentTimeMillis();
        job();
        long end=System.currentTimeMillis();
        System.out.println("执行时间"+(end-start));
    }
}
class A02 extends Template{
    @Override
    public void job() {
        long num=1;
        for (int i = 0; i <=800 ; i++) {
            num*=i;
        }
    }
}
class B02 extends Template{
    @Override
    public void job() {
        long num=0;
        for (int i = 0; i <=800000 ; i++) {
            num+=i;
        }
    }
}

package chapter10.D5抽象类;
​
public class TestTemplate {
    public static void main(String[] args) {
        new B01().calc();
        new A01().calc();
        new A02().calc();
        new A01().calc();
    }
}
​
class A01{
    public void calc(){//可做成模板
        long start=System.currentTimeMillis();
        job();
        long end=System.currentTimeMillis();
        System.out.println("执行时间"+(end-start));
    }
    public void job(){
​
        long num=1;
        for (int i = 0; i <=800 ; i++) {
            num*=i;
        }
    }
}
class B01{
    public void calc(){
        long start=System.currentTimeMillis();
        job();
        long end=System.currentTimeMillis();
        System.out.println("执行时间"+(end-start));
    }
    public void job(){
​
        long num=0;
        for (int i = 0; i <=800000 ; i++) {
            num+=i;
        }
    }
}

接口入门

接口1

package chapter10.D6接口.Interface01;
//接口中所有方法都是public，故不用写修饰符，且默认抽象，不用abstract
public interface Usbinterface {
    public void start();//规定接口相关方法
    public void stop();
}

package chapter10.D6接口.Interface01;
​
public class Camera implements Usbinterface{
    @Override
    public void start() {
        System.out.println("相机开始工作");
    }
​
    @Override
    public void stop() {
        System.out.println("相机停止工作");
    }
}

package chapter10.D6接口.Interface01;
//Phone类实现USB接口（实现Usbinterface规定/声明的方法，重写）
public class Phone implements Usbinterface{
    @Override
    public void start() {
        System.out.println("手机开始工作");
    }
​
    @Override
    public void stop() {
        System.out.println("手机停止工作");
    }
}

package chapter10.D6接口.Interface01;
//带接口的主机工作，驱动其他设备
public class Computer {
    public void work(Usbinterface u){//可传递实现接口的对象
        u.start();//通过接口调用方法
        u.stop();
    }
}

package chapter10.D6接口.Interface01;
​
public class Interface01 {
    public static void main(String[] args) {
        Usbinterface camera = new Camera();//可向上转型
        Phone phone = new Phone();
        Computer computer = new Computer();
        computer.work(phone);//手机接入到电脑
        computer.work(camera);
    }
​
}

接口2

package chapter10.D6接口.Interface02;
​
public interface In02 {
    //写属性和方法
    public int n1=10;
    public void hi();//默认抽象
    default public void ok(){//在jdk8后可以有默认实现方法，需default关键字修饰，或静态方法
        System.out.println("ok...");
    }
    public static void cry(){
        System.out.println("cry...");
    }
}

package chapter10.D6接口.Interface02;
​
public class Interface02 {
    public static void main(String[] args) {
       new A().hi();
    }
}
class A implements In02{
    //要把该接口所有抽象方法实现，除非是抽象类
​
    @Override
    public void hi() {
        System.out.println("hi....");
    }
}

接口3

package chapter10.D6接口.Interface03;
​
public interface In03 {//项目经理
    public void connect();
    public void close();
​
}

package chapter10.D6接口.Interface03;
//A程序员，连接MysqlDB
public class MysqlDB implements In03{
    @Override
    public void connect() {
        System.out.println("连接mysql");
    }
​
    @Override
    public void close() {
        System.out.println("关闭musql");
    }
}

package chapter10.D6接口.Interface03;
//B程序员，连接OracleDB
public class OracleDB implements In03{
    @Override
    public void connect() {
        System.out.println("连接OracleDB");
    }
​
    @Override
    public void close() {
        System.out.println("关闭OracleDB");
    }
}

package chapter10.D6接口.Interface03;
​
public class Interface03 {
    public static void main(String[] args) {
        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);//静态对象不用再创建对象
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }
    public static void t(In03 i){
        i.connect();
        i.close();
    }
}

接口4

package chapter10.D6接口.Interface04;
​
public class Interface04 {
    public static void main(String[] args) {
        System.out.println(IB.n1);//证明静态属性
        //B.n1=20 报错证明是final属性
    }
}
interface IB{
    void hi();
    public static final int n1=100; //默认public static final修饰符
}
interface IC{
    void say();
}
interface ID extends IB,IC{//接口不能再接其他接口，但可继承多个其他接口
​
}
class P implements IB,IC{//一个类可同时实现多接口
    @Override
    public void hi() {
​
    }
​
    @Override
    public void say() {
​
    }
​
}

接口与继承对比

package chapter10.D6接口.ExtendsVsInterface;
//继承拥有父类的功能，接口扩展其他类功能，接口是对单继承的补充
public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey xx = new LittleMonkey("悟空");
        xx.climbing();
        xx.swimming();
        xx.flying();
    }
​
}
class Monkry{
    private String name;
​
    public Monkry(String name) {
        this.name = name;
    }
​
    public String getName() {
        return name;
    }
​
    public void climbing(){
        System.out.println(getName()+"会爬树....");
    }
}
class LittleMonkey extends Monkry implements Fishable,Birdable{//单继承，多接口
    public LittleMonkey(String name) {
        super(name);
    }
​
    @Override
    public void swimming() {
        System.out.println(getName()+"通过学习，可以像鱼儿一样游泳了");
    }
​
    @Override
    public void flying() {
        System.out.println(getName()+"通过学习，可以像鸟儿一样飞翔了");
    }
}
interface Fishable{
    void swimming();
}
interface Birdable{
    void flying();
}

接口数组

package chapter10.D6接口.InterfaceArray;
​
public class InterfaceArray {
    public static void main(String[] args) {
​
        Usb[] usbs=new Usb[2];
        usbs[0]=new P();
        usbs[1]=new C();
        for (int i = 0; i < usbs.length ; i++) {
            usbs[i].work();
            if (usbs[i] instanceof P){//判断运行类型
                ((P) usbs[i]).call();
            }
        }
    }
}
interface Usb{
    void work();
}
class P implements Usb{
    public void call(){
        System.out.println("手机可打电话");
    }
​
    @Override
    public void work() {
        System.out.println("手机工作中");
    }
}
class C implements Usb{
    @Override
    public void work() {
        System.out.println("相机工作中");
    }
}

接口多态

package chapter10.D6接口.InterfacePolyPass;
//演示多态传递
public class InterfacePolyPass {
    public static void main(String[] args) {
        IG ig=new Teacher();//向上转型
        IH ih=new Teacher();
        ih.hi();
    }
}
interface IH{
    void hi();
}
interface IG extends IH{
​
}
class Teacher implements IG{
    @Override
    public void hi() {
        System.out.println("hi");
    }
}

syd2820
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值