Java从零开始（day）

最新推荐文章于 2024-05-19 21:34:53 发布
最新推荐文章于 2024-05-19 21:34:53 发布
阅读量100 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55965645/article/details/125899005
版权

抽象类和接口

1. 抽象类

1.抽象方法没有方法体，必须存在于抽象类中，均使用abstract关键字修饰

2.抽象类不能直接new对象，必须通过new子类的方式(多态向上转型)创建对象

3.子类必须重写父类中所有的抽象方法，除非子类也是抽象类

4.抽象类中可以书写实例属性，实例方法，构造方法，静态属性，静态方法，静态代码块/普通代码块

5.抽象类实现多态的方式与之前一致

package com.atguigu.test1;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 9:38
 *  抽象类
 *  抽象：模糊 不具体
 */
public abstract class Animal {
    // 属性 因为当前事物比较抽象  目前暂不描述

    private String animalType;

    public String getAnimalType() {
        return animalType;
    }

    public void setAnimalType(String animalType) {
        this.animalType = animalType;
    }

    public Animal(String animalType){
        this.animalType = animalType;
    }

    public Animal(){}

    public static void main(String[] args) {

    }

    static{
        System.out.println("hello abstract class");
    }

    {
        System.out.println("hello abstract class"); // 每次new子类对象 都会执行一次
    }


    /**
     *  1.抽象方法没有方法体，必须存在于抽象类中，均使用abstract关键字修饰
     *  2.抽象类不能直接new对象，必须通过new子类的方式(多态向上转型)创建对象
     *  3.子类必须重写父类中所有的抽象方法，除非子类也是抽象类
     *  4.抽象类中可以书写实例属性，实例方法，构造方法，静态属性，静态方法，静态代码块/普通代码块
     *  5.抽象类实现多态的方式与之前一致
     */
    public abstract void eat();



    public void print(){
        System.out.println("动物介绍");
    }

}

package com.atguigu.test1;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 9:59
 */
public class Tiger extends Animal{
    @Override
    public void eat() {
        System.out.println("老虎吃肉");
    }


    public void print(){
        System.out.println("老虎的个虎介绍");
    }
}


package com.atguigu.test1;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 10:02
 */
public abstract class Pet extends Animal{

    public abstract void playWithMaster();

}



package com.atguigu.test1;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 10:04
 */
public class Dog extends Pet{
    @Override
    public void playWithMaster() {
        System.out.println("狗狗和主人玩耍");
    }

    @Override
    public void eat() {
        System.out.println("狗狗吃骨头");
    }

    public void printDog(){

    }

}


package com.atguigu.test1;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 9:58
 */
public class TestAnimal {
    public static void main(String[] args) {
//        Animal animal = new Animal(); 不能直接new抽象类对象

        Tiger tiger = new Tiger(); // 多态向上转型  可以访问子类继承/重写父类的方法 不能访问独有方法

        tiger.eat();


        Animal dog1 = new Dog();
        dog1.eat();


        Pet dog2 = new Dog();
        dog2.eat();
        dog2.playWithMaster();
    }
}

2. 抽象类案例

门是一个比较广泛的范围，因为没有明确具体是那种门(防盗门、普通门)

所以此类中门最基本的行为我们无法具体描述，使用abstract修饰

package com.atguigu.test2;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 10:45
 *  需求：实现各种门的操作 开门 以及 关门
 *  门
 */
public abstract class Door {
    private String brand;
    private double price;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public Door() {
    }

    public Door(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    public abstract void openDoor();

    public abstract void closeDoor();


}


package com.atguigu.test2;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 10:48
 */
public class CommonDoor extends Door{

    public CommonDoor() {
    }

    public CommonDoor(String brand, double price) {
        super(brand, price);
    }

    @Override
    public void openDoor() {
        System.out.println("普通门开门，插入钥匙，轻轻一转，吱呀一声，门开了");
    }

    @Override
    public void closeDoor() {
        System.out.println("普通门关门，duang的一声，门关了");
    }
}


package com.atguigu.test2;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 10:47
 */
public class SecurityDoor extends Door{
    private String password;

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }


    public SecurityDoor(String password,String brand,double price){
        super(brand,price);
        this.password = password;
    }

    public  SecurityDoor(){}


    @Override
    public void openDoor() {
        System.out.println("防盗门开门，输入密码+指纹+钥匙+人脸识别，门开了");
    }

    @Override
    public void closeDoor() {
        System.out.println("防盗门关门，自动关门");
    }
}


package com.atguigu.test2;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 10:50
 *  人类 可以操作门
 */
public class Person {

    public void openSecurityDoor(SecurityDoor sd){
        sd.openDoor();
    }

    public void closeSecurityDoor(SecurityDoor sd){
        sd.closeDoor();
    }

    // 如果按照以上的写法 针对普通门依然需要写两个方法 分别用于 开和关


    public void open(Door door){
        door.openDoor();
    }


    public void close(Door door){
        door.closeDoor();
    }


    // 书写买门的操作

    public Door buyDoor(double money){
        if(money >= 2000){
            return new SecurityDoor("8956","大金刚",8888);
        }else{
            return new CommonDoor("小金刚", 1200);
        }
    }
}

3. final关键字

final 关键字：单词-最终

final使用场景：可以用于修饰属性、方法、类

3.1 final修饰属性

final修饰属性：称之为常量 表示此属性是一个固定的值 其值不能改变 只能被赋值一次

必须在定义的时候赋值 或者 在构造方法中赋值 这两种赋值方式 都是为了保证 我们在使用常量之前 是有具体值的

通常在定义的时候赋值 99%

常量名称全部大写，多个单词之间使用下划线分割 COUNTRY_NAME

package com.atguigu.test3;

import sun.util.resources.cldr.tr.CurrencyNames_tr;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 11:36
 *  final 关键字：单词-最终
 *  final使用场景：可以用于修饰属性、方法、类
 *
 *  final修饰属性：称之为常量 表示此属性是一个固定的值 其值不能改变  只能被赋值一次
 *  必须在定义的时候赋值 或者 在构造方法中赋值  这两种赋值方式 都是为了保证 我们在使用常量之前 是有具体值的
 *  通常在定义的时候赋值  99%
 *
 *  常量名称全部大写，多个单词之间使用下划线分割  COUNTRY_NAME
 *
 *  final修饰方法，表示此方法可以继承，不能被重写
 *  final修饰类，此类不能被继承
 */
public class Test1 {

    final double PI = 3.14;
    final String COUNTRY_NAME;
    double radius;

    public Test1(){
        COUNTRY_NAME = "中国";
    }


    public Test1(double radius){
        this.radius = radius;
        COUNTRY_NAME = "中华人民共和国";
    }


    public static void main(String[] args) {
        Test1 test1 = new Test1();

        test1.radius = 10;

//        test1.pi = 3.24;

        System.out.println(test1.PI * test1.radius * test1.radius);

    }

}

回顾我们之前使用final修饰常量 发现通常不能被改变的数据 也没有必要存在多份 所以我们可以使用static修饰

public static final 静态常量

全局静态常量是实际开发中使用比较多的 通常在定义的时候直接赋值 或者 在静态代码块中赋值

以上两种方式依然是为了保证使用静态常量之前 是有具体值的

package com.atguigu.test4;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 14:12
 *  回顾我们之前使用final修饰常量  发现通常不能被改变的数据 也没有必要存在多份  所以我们可以使用static修饰
 *
 *  public static final  静态常量
 *  全局静态常量是实际开发中使用比较多的  通常在定义的时候直接赋值 或者  在静态代码块中赋值
 *  以上两种方式依然是为了保证使用静态常量之前 是有具体值的
 */
public class Test1 {
    public static final double PI = 3.14;

    public static final String COUNTRY_NAME;

    static{
        COUNTRY_NAME = "中国";
    }



}
3.2 final修饰方法

final修饰的方法 不能被重写 可以被继承

package com.atguigu.test4;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 14:16
 *
 *  final修饰的方法  不能被重写 可以被继承
 */
public class A {
    public final void m1(){
        System.out.println("A类m1方法");
    }

    public void m2(){
        System.out.println("A类m2方法");
    }

    public void m3(){
        System.out.println("A类m3方法");
    }

    public static void main(String[] args) {
        B b = new B();
        b.m1();
    }


}

class B extends A{
    public void m1(){ // 此处编译错误  

    }

    public void m3(){

    }




}
3.3 final修饰类

被final修饰的类 不能被继承 因为继承意味着改变

package com.atguigu.test4;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 14:18
 */
public final  class C {
}

//class D extends C{  被final修饰的类 不能被继承  因为继承意味着改变

//}

4. 接口

1.接口中的方法 默认都是全局 抽象 方法 不管是否书写 都将使用public abstract修饰

2.接口不能直接new对象，必须通过new实现类(子类)的方式来创建对象(多态向上转型)

3.实现类(子类)必须实现（重写）接口中所有的抽象方法 除非实现类也是抽象类 或者 接口

4.接口不能书写普通属性(默认都是全局静态常量 不管是否书写均使用 public static final 修饰)、构造方法、普通方法、静态方法(JDK1.7-)

5.一个类只能继承一个父类，但是可以实现多个接口

6.接口实现多态的方式与之前一致

JDK1.8 可以书写普通方法 在返回值之前加上default关键字 静态方法

面试题：Java支持多继承吗？

不支持，但是可以通过接口继承多个接口的方式，实现类似多继承的效果

package com.atguigu.test6;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 14:51
 *  接口相当于一种约定，只关注约定，不关注具体实现
 *
 *  Java中的接口使用interface来修饰      UI    User  Interface
 */
public interface USB {

    int NUM = 10;
//    public USB(){
//
//    }

    /**
     *  1.接口中的方法 默认都是全局 抽象 方法 不管是否书写 都将使用public abstract修饰
     *  2.接口不能直接new对象，必须通过new实现类(子类)的方式来创建对象(多态向上转型)
     *  3.实现类(子类)必须实现（重写）接口中所有的抽象方法 除非实现类也是抽象类 或者 接口
     *  4.接口不能书写普通属性(默认都是全局静态常量 不管是否书写均使用 public static final 修饰)、构造方法、普通方法、静态方法(JDK1.7-)
     *  5.一个类只能继承一个父类，但是可以实现多个接口
     *  6.接口实现多态的方式与之前一致
     *
     *  JDK1.8 可以书写普通方法 在返回值之前加上default关键字  静态方法
     *
     *  面试题：Java支持多继承吗？
     *      不支持，但是可以通过接口继承多个接口的方式，实现类似多继承的效果
     */
    void connect();



    public default void m1(){

    }

    public static void m2(){

    }

}


package com.atguigu.test6;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 15:00
 */
public class Mouse implements  USB{
    @Override
    public void connect() {
        System.out.println("鼠标链接上USB接口，可以点击世界了");
    }
}




package com.atguigu.test6;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 15:02
 */
public abstract class Convert implements  USB{

    public abstract void convert();
}


package com.atguigu.test6;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 15:03
 */
public class HuaWei extends Convert{
    @Override
    public void convert() {
        System.out.println("网线链接华为转换器");
    }

    @Override
    public void connect() {
        System.out.println("转换器连接USB接口");
    }
}


package com.atguigu.test6;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/20 15:01
 */
public class TestUSB {
    public static void main(String[] args) {
//        USB usb = new USB();

        USB mouse = new Mouse(); // 多态向上转型

        mouse.connect();


    }
}
少喝点酒多吃菜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java从零开始(Day08)
weixin_55965645的博客
07-15 215
Java从零开始
从零开始学python
01-09
从零开始学python 太原理工大学机器人团队20天学习打卡 day1 ​ 为了学习一门新的语言，我们首先必定需要先了解开发环境。Linux系统因为其安全、免费且方便多用户使用而多用于各种服务器，又因为其体积小巧而被用于...
java从零开始 day31
m0_62499535的博客
05-05 1065
初识Tomcat 服务端： 自定义 C Tomcat服务器 S：Java后端开发 客户端： 自定义 C 浏览器 B 1.7 UDP 数据报包（DatagramSocket）发送与接收 发送端： package com.mine.lesson3; import java.net.*; //不需要连接服务器 public class UdpClientDemo01 { public static void main(String[] args) throws Exception { ..
java从零开始 day14
m0_62499535的博客
04-07 675
3.数组的使用 For-Each循环 数组作方法入参 数组作返回值 多维数组： 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。 •二维数组 int a[][]=new int[2][5]; •解析：以上二维数组a 可以看成一个两行五列的数组。 •思考：多维数组的使用？ num[1] [0]; 实例（二维数组的使用）： Arrays类： ·数组的工具类java.util.Arrays •由于数组对象本身并没有什么方法可...
java从零开始 day3
m0_62499535的博客
03-29 276
今天开始进入java正题 一、java基础语法 1.注释 ：java中的注释有三种：单行注释、多行注释、文档注释（javadoc）. 单行注释：// 多行注释：/（ 注释内容）/ 文档注释：/** *@Description （干了什么事） */@author 某某某 */ 2.标识符和关键字 关键字： 标识符：是自己起的，比如class后面就是类名，int后面的就是变量名 “void main” main就是方法名。 java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。 所有的标识符都
java从零开始 day2
m0_62499535的博客
03-29 52
1.java程序运行机制 编译型：直接“翻译” 解释型：一句一句地“翻译”
JAVA从零开始养成
nice_chao的博客
12-06 411
Day1. JAVA基础： 计算机程序就是多个指令的集合。 JAVA语言特点：平台无关，简单，面向对象，可移植性，健壮性，安全性，多线程。 变量名，方法名，属性名：都是基于驼峰命名法，通常第一个单词首字母小写其后单词首字母大写。 类名，项目名：单词首字母大写。 常量名：全大写。 模运算：%（取余）。 int类型数据不可以自动转化为char,double不可以自动转化为int。 运算符的优先级： a.、最高优先级：小括号，即（） b....
从0开始的Java基础
Cobrander2_0的博客
06-01 1219
Java
Java从零开始系列02：对象与类
a789253的博客
05-02 882
学习目标： 面向对象程序设计入门 如何创建标准Java类库中的对象 如何编写自己的类 一、面向对象程序设计概述 面向对象程序设计（object-oriented programming,OOP）是当今主流的程序设计范型，由于Java是面向对象的，所以必须熟悉OOP才能很好的使用Java。 面向对象的程序是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。 传统的结构化程序设计通过设计一系列的过程（算法）来求解问题，而OOP却调换了这个顺序，将数据放在第一位，然后再考虑操作数据的
从零开始学Java-Day05（1）：方法
weixin_52583865的博客
01-10 148
方法的理解
从零开始学python第六篇
12-22
从零开始学python第六篇 太原理工大学机器人团队20日打卡day6 1、模块 2、高级变量 ​ 模块应该说是python最重要的知识之一。学会模块相关方面知识，对于非计算机专业在未来利用编程知识有极大的用处。毕竟在我看来...
从零开始学python第二章
01-21
从零开始学python第二章 面向对象第一篇 太原理工大学机器人团队20日打卡day9 ​ 当我们讨论python时不得不讨论到面向对象，而我身为机器人团队的一名成员，在平时设计的时候可以通过把机器人的各个部分设计成不同...
从零开始学python第八篇
01-20
从零开始学python第八篇 太原理工大学机器人团队20日打卡day8 ​ 今天的内容主要是对前面内容的一部分补充，也就是说，到今天为止，python的所有基础内容就学习完了，剩下的主要为面向对象和项目实战 1、 可变类型...
jar包增量更新分析
junlaiyan的专栏
05-16 288
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 649
本文主要提供用java实现的拼图小游戏源代码。
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 139
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 258
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
C++ 11
qq_65112813的博客
05-17 664
对于类类型，如果定义了接受。
Java如何定义日期从周一开始
06-13
在Java中，可以使用Calendar类来定义日期从周一开始。具体来说，可以使用以下代码： ```java // 创建一个Calendar实例 Calendar calendar = Calendar.getInstance(); // 设置一周的第一天为周一 calendar....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值