day10学习笔记

已于 2022-07-26 08:50:10 修改
阅读量214 收藏
点赞数
分类专栏： 学习总结 文章标签： 学习 java
于 2022-07-22 17:35:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53884348/article/details/125932086
版权
本文详细介绍了Java中的抽象方法、抽象类、接口定义、实现类及其关系，并通过案例进行解析，强调了抽象类和接口在多层继承和实现中的应用。
摘要由CSDN通过智能技术生成

一、抽象方法

        概念：只有方法的声明，没有方法实现，并用关键字abstract来修饰的方法，就是抽象方法

        语法： 访问修饰符 abstract 返回值类型  方法名称(参数列表);

        例子：public abstract void  showInfo (int age);

        作用：简化方法的编写

        注意点：抽象方法必须写在抽象类中

        使用场景：抽象方法一般定义在父类中，用于给子类进行重写

二、抽象类

        概念：使用abstract关键字修饰的类就是抽象类

        语法：访问修饰符  abstract    class   类名{}

        例子：public   abstract  class  Fu{}

        成员：1.成员变量    2.构造方法   3.  静态方法   4. 成员方法  5. 抽象方法

        说明：

                抽象类是不能实例化对象的

                抽象类中构造方法一般用于给子类进行调用

                抽象方法一定是在抽象类中 但是抽象类中不一定都是抽象方法 可以有其他方法

                如果父类为抽象类 子类就必须实现父类中所有的抽象方法

                除非子类也是抽象类就可以不实现

        抽象类与抽象方法的关系：

                抽象方法必须在抽象类中

                抽象方法可以有其他的成员方法 不止抽象方法

        抽象类使用场景：抽象类一般用作于父类

三、案例

        需求：

         分析：

         代码：

               员工类

package com.qf.text.text01;

public abstract class Emp {
    //定义私有属性
    private String name;
    private int noId;
    private double pay;
//定义构造方法
    public Emp() {
    }

    public Emp(String name, int noId, double pay) {
        this.name = name;
        this.noId = noId;
        this.pay = pay;
    }
    //定义get和set方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNoId() {
        return noId;
    }

    public void setNoId(int noId) {
        this.noId = noId;
    }

    public double getPay() {
        return pay;
    }

    public void setPay(double pay) {
        this.pay = pay;
    }
    //定义抽象方法work
    public abstract void work();
}

       程序员类

package com.qf.text.text01;

public class Coder extends Emp {
    //定义私有属性
    private double money;
    //定义构造方法

    public Coder() {

    }

    public Coder(String name, int noId, double pay, double money) {
        super(name, noId, pay);
        this.money = money;
    }
    //定义get和set方法


    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
//重写work方法
    @Override
    public void work() {
        System.out.println("正在撸代码");
    }
}

        测试员工类

package com.qf.text.text01;

public class Tester extends Emp {
    //定义构造方法

    public Tester() {
    }

    public Tester(String name, int noId, double pay) {
        super(name, noId, pay);
    }
//重写work方法
    @Override
    public void work() {
        System.out.println("测试软件");
    }
}

        项目经理类

package com.qf.text.text01;

public class ProjectManager extends Emp {
    //定义私有属性
    private double money;
    //定义构造方法

    public ProjectManager() {
    }

    public ProjectManager(String name, int noId, double pay, double money) {
        super(name, noId, pay);
        this.money = money;
    }
    //定义get和set方法


    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
//重写work方法
    @Override
    public void work() {
        System.out.println("提交项目");
    }
}

        测试类

        

package com.qf.text.text01;

public class Test {
    public static void main(String[] args) {
        //使用多态方法实例化对象
        Emp e1 = new Coder("程序员",0001,13000,3000);
        e1.work();
        Emp e2 = new Tester("测试员",0002,12000);
        e2.work();
        Emp e3 = new ProjectManager("项目经理",0003,13000,5000);
        e3.work();
    }

}

四、接口的定义

        1.开发中的接口就类似生活中的接口  就是定义一个规范和约束条件

        2.规范：就是定义一些抽象方法

        3.关键字：interface

        4.接口编译之后也是一个.class文件  Class对象

        5.语法：

                        访问修饰符  interface   接口的名称{

                                抽象方法()

                        }

        6.例子： public interface Inner  {}

        7.成员：

                A. 接口中变量都是静态常量 默认使用 public static final 来进行修饰

                B.接口中的方法：默认使用public abstract 来进行修饰

                        a.在jdk1.8之前 接口中只能有抽象方法

                        b.在jdk1.8之后 接口中可以有抽象方法 静态方法  默认的方法(使用default修饰的方法)

                        c.在jdk1.9之后可以有私有的方法

                C.接口中没有构造方法

        8.注意点：

                接口中没有构造方法 

                接口不能实例化对象

                接口一般用于来约束实现类 用于提供给实现类来实现接口的(实现规范)

五、实现类

        1.概念：实现接口的类就是实现类

        2.分类：

                单实现：只实现一个接口

                多实现：同时实现多个接口

        3.单实现：

                语法： 访问修饰符  class 类名  implments  接口名称{}

                例子：public   class  Impl  implents  Inner{}

                原则：实现类必须实现接口中所有的抽象方法（实现类是抽象方法就可以不实现）

        4.多实现：

                语法：访问修饰符  class 类名  implments  接口名称1,接口实现2{}

                例子：public class Impl implments Inner1,Inner2{}

                原则：实现类必须实现接口中所有的抽象方法

                注意点：如果多个接口中定义同名的抽象方法 的时候 实现类只需要实现接口重名的一个方法就可以了

六、案例

        需求

        分析

         代码

package com.qf.text.text02;

public interface USBInterface {
    //定义抽象方法
    void star();//开启
    void close();//关闭
    
}




package com.qf.text.text02;

public class Mouse implements USBInterface {
    @Override
    public void star() {
        System.out.println("鼠标开启");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }
}




package com.qf.text.text02;

public class KeyBoard implements USBInterface {
    @Override
    public void star() {
        System.out.println("键盘开启");
    }

    @Override
    public void close() {
        System.out.println("键盘关闭");
    }
}



package com.qf.text.text02;

public class NoteBook {
    //定义成员方法
    public void star(){
        System.out.println("笔记本开启");
    }
    //定义一个已USBInterface为参数的方法来控制鼠标和键盘的开启和关闭
    public void use(USBInterface usb){
        usb.star();
        usb.close();
    }

    public void close(){
        System.out.println("笔记本关闭");
    }
}




package com.qf.text.text02;

import java.nio.file.attribute.UserDefinedFileAttributeView;

public class Test {
    public static void main(String[] args) {
        //实例化笔记本对象
        NoteBook note = new NoteBook();
        //开启笔记本
        note.star();
        //利用多态实例化一个鼠标对象
        USBInterface usb1 = new Mouse();
        //通过笔记本对象把鼠标对象当做参数传入方法中 开启鼠标 和关闭
        note.use(usb1);
        //利用多态实例化一个键盘对象
        USBInterface usb2 = new KeyBoard();
        //通过笔记本对象把键盘对象当做参数传入方法中 开启键盘 和关闭
        note.use(usb2);
        //关闭笔记本
        note.close();
    }
}

 七、类与接口，类与类之间的关系

        1.类与类：只能单继承，多层继承，不能多继承

        2.类与接口：单实现，多实现

        3.接口与接口：单继承，多继承，多层继承

八、案例

需求-分析：

 代码：

package com.qf.test.test03;

public interface Pager {
    //定义抽象方法
    String getPager();
}


package com.qf.test.test03;

public class A4Pager implements Pager{
    @Override
    public String getPager() {
        return "A4纸张";
    }
}




package com.qf.test.test03;

public class A3Pager implements Pager{
    @Override
    public String getPager() {
        return "A3纸张";
    }
}




package com.qf.test.test03;

public interface Link {
    String getLink();
}



package com.qf.test.test03;

public class WhiteLink implements Link {
    @Override
    public String getLink() {
        return "白色墨盒";
    }
}



package com.qf.test.test03;

public class ColorLink implements Link {
    @Override
    public String getLink() {
        return "彩色墨盒";
    }
}



package com.qf.test.test03;

public class Printer {
    //定义私有的属性 数据类型为 引用数据类型中的接口
    private Pager pager;
    private Link link;
    //定义构造方法给属性赋值  也可以使用get和set方法进行赋值

    public Printer() {
    }

    public Printer(Pager pager, Link link) {
        this.pager = pager;
        this.link = link;
    }
    //定义成员方法调用实现类的方法
    public void print(){
        System.out.println(pager.getPager()+"\t"+link.getLink());
    }
}



package com.qf.test.test03;

public class Test {
    public static void main(String[] args) {
        //使用多态的方法实例化对象
        //纸张
        Pager p1 = new A3Pager();
        Pager p2 = new A4Pager();
        //墨盒
        Link l1 = new WhiteLink();
        Link l2 = new ColorLink();
        //实例化打印机对象
        Printer p = new Printer(p1,l1);
        p.print();
        Printer pri = new Printer(p2,l2);
        pri.print();
        Printer printer = new Printer(p1,l2);
        printer.print();
    }
}

九、代码块

        1.概念：编写在大括号中的代码，就是代码块{代码}

        2.分类：

                局部代码块：

                        位置：定义在方法中

                        语法：{代码}

                        作用：用于限制变量的生命周期

                        说明：       

                                在局部代码块定义的变量

                                在局部代码块里重新赋值后

                                在局部代码块外获取到的是改变后的值

                构造代码块：

                        位置：定义在类中，方法外

                        语法：{代码}

                        作用：用于给成员变量赋值

                        说明：

                                构造代码块是由jvm执行的

                                构造代码块优先与构造方法执行

                                每次实例化对象都会执行构造代码块

                静态代码块：

                        位置：定义在类中 方法外

                        语法：static{代码}

                        作用：用来加载一次配置文件  因为配置文件都只有加载一次如 jdbc配置文件 lo4j配置文件

                        说明：

                                静态代码块优先与构造方法执行

                                静态代码块可以给静态变量赋值

                                静态代码块只在类加载的时候执行一次

白昼乌龙茶
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白昼乌龙茶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值