day19-java

已于 2023-03-12 17:33:57 修改
阅读量220 收藏
点赞数 1
分类专栏： Java 文章标签： java
于 2023-03-07 23:38:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/agjnhga/article/details/129394372
版权

目录

包机制

package com.itheima.demo01package;

import com.itheima.demo02modifier.PackageTest;

/**
 * 包机制：
 * 1.同一个包中的类可以互相直接访问
 * 2.不同包下的类需要导包才能使用
 * 重点：
 * 3.如果需要使用不同包下类名相同的两个类，只能导入其中一个类
 * 另一个类需要使用全类名访问
 * @author shifan
 */
public class DemoPackage01 {
    public static void main(String[] args) {
        PackageTest packageTest = new PackageTest();
        //全类名访问
        com.itheima.demo01package.cast.PackageTest packageTest1 = new com.itheima.demo01package.cast.PackageTest();
    }
}
/*第一个PackageTest*/
package com.itheima.demo01package.cast;

public class PackageTest {
}
/*第二个PackageTest*/
package com.itheima.demo02modifier;

public class PackageTest {
}

修饰符

protected修饰的成员只能在本包下以及其他包下的子类才能访问

package com.itheima.demo02modifier;

/**
 * 权限修饰符：
 * public>protected>缺省>private
 */
public class DemoModifierDad {
    private void privateMethod(){
        System.out.println("private");
    }
    void Method(){
        System.out.println("缺省");
    }
    protected void protectedMethod(){
        System.out.println("protected");
    }
    public void publicMethod(){
        System.out.println("public");
    }
}


package com.itheima.demo02modifier.cast;

import com.itheima.demo02modifier.DemoModifierDad;
/*
测试protected访问权限
*/
public class DemoModifierSon extends DemoModifierDad {
    public static void main(String[] args) {
        DemoModifierDad dad = new DemoModifierDad();
        //注意：其他包下父类同样无法访问protected方法
        //dad.protectedMethod();报错
        DemoModifierSon son = new DemoModifierSon();
        //其他包下子类访问
        son.protectedMethod();
    }

final关键字

package com.itheima.demo03final;

import java.util.Arrays;

/**
 * final关键字表示最终，它的作用：
 * 1.final修饰类，表示该类为最终类，无法被继承
 * 2.final修饰方法，表示该方法为最终方法，无法被重写
 * 3.final修饰变量，则该变量只能被赋值一次
 * 注意：
 * 1.如果final修饰的是基本数据类型，则该类型的数据值无法被改变
 * 2.如果修饰的是引用数据类型，则其地址值无法被改变，但是它的内容可改变
 */
public class DemoFinal01 {
    /*
    final修饰实例成员变量(几乎不用)
     */
    private final String name = "法外狂徒";
    /*
    final修饰静态成员变量
    public static final 修饰的是常量
     */
    public static final int AGE = 18;

    public static void main(String[] args) {
        /*
        final修饰局部变量
        */
        final int a = 10;
//        a = 11;第二次赋值

        final int[] arr = {1,2,3};
        int[] arr1 = {2,3,4,5};
        System.out.println(Arrays.toString(arr));
        //引用数据类型的内容可以改变
        arr[0] = 0;
        System.out.println(Arrays.toString(arr));
//        arr = arr1;第二次赋值

        DemoFinal01 d = new DemoFinal01();
//        d.name = "张三";第二次赋值
        System.out.println(d.name);
//        AGE = 20;第二次赋值
    }
}

常量

package com.itheima.demo03final;

import java.util.Random;

/**
 * 常量：
 *     必须有初始化值
 *     常量命名规范：所有字母大写，单词之间用下划线连接
 *     编译时会进行“宏替换”，将常量全部替换为字面量
 *     好处和作用：可用于做系统配置信息，方便程序维护，提高可读性
 *     常用来做信息标志和分类,但入参值不受约束，不够严谨
 *     即不用常量名直接使用数据值同样能运行，一旦报错很麻烦
 */
public class DemoFinal02Constant {
    public static final int UP = 1;
    public static final int DOWN = 2;
    public static final int LEFT = 3;
    public static final int RIGHT = 4;
    public static void main(String[] args) {
        int[] arr = {UP,DOWN,LEFT,RIGHT};
        Random r = new Random();
        int i = arr[r.nextInt(5)+1];
        switch (i){
            case UP:
                System.out.println("向上跳");
                break;
            case DOWN:
                System.out.println("向下跳");
                break;
            case LEFT:
                System.out.println("向左走");
                break;
            case RIGHT:
                System.out.println("向右走");
                break;
            default:
                break;
        }
    }
}

枚举

package com.itheima.demo04enum;

/**
 * 枚举类：
 * 用于做信息的标志和信息的分类
 * 第一行必须罗列枚举类实例名称，全大写字母
 */
public enum Orientation {
    UP,DOWN,LEFT,RIGHT;
}

package com.itheima.demo04enum;

/**
 * 枚举类做信息分类
 */
public class DemoEnum01 {
    public static void main(String[] args) {
        Orientation o = Orientation.UP;
        //switch已兼容枚举类
        switch (o){
            case UP:
                System.out.println("向上跳");
                break;
            case DOWN:
                System.out.println("向下跳");
                break;
            case LEFT:
                System.out.println("向左走");
                break;
            case RIGHT:
                System.out.println("向右走");
                break;
            default:
                break;
        }
    }
}

抽象类

package com.itheima.demo05abstract;

/**
 * 抽象类：
 * 一个类中如果定义了抽象方法，则这个类必须申明为抽象类
 * 抽象类和抽象方法都是用abstract修饰，抽象方法只有方法签名没有方法体
 * 抽象类一般作为父类被继承
 * 一个类如果继承了抽象类，则必须重写所有抽象方法，否则也要申明为抽象类
 * abstract不能修饰变量、代码块、构造器
 * 普通类有的成员方法、成员变量、构造器抽象类都有
 * 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
 * 抽象类无法实例化，因为抽象方法没有方法体
 */

public abstract class Card {
    private String userName;
    private double money;

    public Card(String userName, double money) {
        this.userName = userName;
        this.money = money;
    }

    public Card() {
    }

    public abstract void pay(double money);

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

package com.itheima.demo05abstract;

public class GoldCard extends Card {
    public GoldCard() {
    }

    public GoldCard(String userName, double money) {
        super(userName, money);
    }

    @Override
    public void pay(double money) {
        System.out.println(getUserName()+"，您本次消费"+money);
        System.out.println("您当前余额为："+getMoney());
        double m = money * 0.8;
        System.out.println("您实际支付："+ m);
        setMoney(getMoney()-m);
    }
}

package com.itheima.demo05abstract;

public class SilverCard extends Card {
    @Override
    public void pay(double money) {
        System.out.println(getUserName()+"，您本次消费"+money);
        System.out.println("您当前余额为："+getMoney());
        double m = money *0.85;
        System.out.println("实际支付："+ m);
        setMoney(getMoney()-m);
    }

    public SilverCard(String userName, double money) {
        super(userName, money);
    }

    public SilverCard() {
    }
}

package com.itheima.demo05abstract;

/**
 测试类
 */
public class Demo01Abstract {
    public static void main(String[] args) {
        GoldCard c1 = new GoldCard("张三",10000);
        c1.pay(200);
        System.out.println(c1.getMoney());
        SilverCard s1 = new SilverCard("李四",5000);
        s1.pay(100);
        System.out.println(s1.getMoney());
    }
}

方法模板

package com.itheima.demo06template;

/**
 * 方法模板模式：
 * 重复的部分定义在方法内，
 * 不一样的部分使用抽象方法交给子类去实现
 */
public abstract class Student {
    public final void write(){
        System.out.println("\t\t《标题》");
        System.out.println("今天，我来介绍一下我的同桌");
        System.out.println(writeMain());
        System.out.println("我同桌也太(～￣(OO)￣)ブ了");
    }
    public abstract String writeMain();
}

package com.itheima.demo06template;

public class ChildStudent extends Student {
    @Override
    public String writeMain() {
        return "我同桌没头脑";
    }
}

package com.itheima.demo06template;

public class MiddleStudent extends Student {
    @Override
    public String writeMain() {
        return "我同桌巨能吃";
    }
}

接口

接口概述

package com.itheima.demo07interface.interfaceimplements;

/**
 * 接口类：
 * 接口体现的是一种规范，规范一定是公开的
 */
public interface Demo01Interface {
    //成分特点：JDK8之前，接口中只能写常量和抽象方法
    /**常量
    注意：因为接口体现规范思想，规范默认公开，所以public static可以省略不写
     */
    String name = "张三";
    //public static String name = "张三";

    /**
     * 抽象方法
     * 同样public abstract可以省略
     */
    void walk();
    //public abstract void run();

    void eat();
}

接口用法

package com.itheima.demo07interface.interfaceimplements;

/**
 * 接口的用法：
 * 被类实现，这种类称为实现类,关键字：implements
 * 格式：修饰符 class 实现类 implement 接口1，接口2，接口3...{}
 * 接口与接口直接可以多继承
 */
public interface Demo02InterfaceImplements extends Demo01Interface {
    void run();
}

package com.itheima.demo07interface.interfaceimplements;


/**
 * 一个类可以实现多个接口，接口之间用逗号隔开
 * Demo02InterfaceImplements接口继承了Demo01Interface接口
 * 所以Implement02Interface类同时实现了两个接口
 */
public class ImplementInterface implements Demo02InterfaceImplements {
    @Override
    public void walk() {

    }

    @Override
    public void run() {

    }

    @Override
    public void eat() {

    }

}

package com.itheima.demo07interface.interfaceimplements;

/**
 * 测试类
 */
public class TestInterface {
    public static void main(String[] args) {
        ImplementInterface i = new ImplementInterface();
        i.eat();
        i.walk();
    }
}

接口特点

package com.itheima.demo07interface.interfacenewfeature;

/**
 * 从jdk8开始，新增的方法，可以用方法体
 * 弥补了增加接口中抽象方法后所有实现类都要重写新抽象方法的不足
 */
public interface Demo03InterfaceNewFeature {
    /*
    一、默认方法（实例方法）
    必须使用default修饰，默认使用public修饰
    接口创建不了对象，这个方法过继给了实现类，
    只能使用实现类创建的对象调用
    */

    default void run(){
        System.out.println("跑");
        //play();
    }

    /*
    二、静态方法
    必须使用static修饰，
    接口的静态方法，只能使用接口名调用
    */

    static void eat(){
        System.out.println("吃");
    }

    /*
    三、私有方法（实例方法）
    jdk9添加，必须使用private修饰，只在接口内部可以访问
     */

	/*private void play(){
        System.out.println("玩");
    }*/
}


package com.itheima.demo07interface.interfacenewfeature;
/**
测试类
*/
public class Test implements Demo03InterfaceNewFeature {
    public static void main(String[] args) {
        Test t = new Test();
        t.run();
        Demo03InterfaceNewFeature.eat();
    }
}

接口注意事项

package com.itheima.demo07interface.interfaceattention;

/**
 * 接口注意事项：
 * 1.接口不能创建对象
 * 2.一个类实现多个接口，多个接口中有同样的静态方法不冲突，因为接口的静态方法只能用接口名调用
 * 3.一个类继承了父类又实现类接口，父类和接口中有同名方法，默认调用父类的
 * 4.一个类实现了多个接口，多个接口中存在同名的默认方法不冲突，但要重写这个方法
 * 5.一个接口继承多个接口没问题，但如果多个接口中存在规范冲突则不行
 */
public class Demo04InterfaceAttention implements A,B{
    @Override
    public void eat() {
        System.out.println("重写吃");
    }

    @Override
    public void run() {

    }

    public static void main(String[] args) {
        Demo04InterfaceAttention d = new Demo04InterfaceAttention();
        d.eat();
    }
}

多态

多态概述

package com.itheima.demo08polymorphic.polymorphicfeature;

/**
 * 多态：
 * 同类型的对象，执行同一个行为，会有不同的行为特征
 * 常见形式：
 * 1.父类类型 对象名 = new 子类构造器;
 * 2.接口 对象名 = new 实现类构造器；
 * 多态的前提：
 * 实现/继承关系、父类引用指向子类对象、子类重写父类方法
 */
public class Test {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Animal dog = new Dog();
        /*
        多态方法调用，编译看左边，左边存在该方法才能编译，
        运行看右边，实际执行还是执行右边的方法
        */
        //修勾跑得贼快
        dog.run();

        Animal tortoise = new Tortoise();
        //乌龟属实跑不动
        tortoise.run();
        /*
        变量调用：
        编译看左边，运行也看左边
        多态侧重行为的多态*/
        //动物的名字
        System.out.println(dog.name);
        //调用修勾的名字:修勾名字
        System.out.println(((Dog) dog).name);
        //动物的名字
        System.out.println(tortoise.name);
        //调用乌龟的名字：乌龟名字
        System.out.println(((Dog) dog).name);
    }
}

父类：

package com.itheima.demo08polymorphic.polymorphicfeature;

public class Animal {
    public String name = "动物名字";
    public void run(){
        System.out.println("动物都会跑");
    }
}

子类：

package com.itheima.demo08polymorphic.polymorphicfeature;

public class Dog extends Animal {
    public String name = "修勾名字";
    @Override
    public void run(){
        System.out.println("修勾跑得贼快");
    }

}

package com.itheima.demo08polymorphic.polymorphicfeature;

public class Tortoise extends Animal {
    public String name = "乌龟名字";
    @Override
    public void run(){
        System.out.println("乌龟属实跑不动");
    }
}

多态的优势

请添加图片描述

package com.itheima.demo08polymorphic.polymorphicadvance;

/**
 * 多态的优势：
 * 多态形式下，右边对象可以实现解耦合，方便拓展和维护
 * 定义方法的时候使用父类型作为参数，就可以接收该父类的一切子类对象，
 * 体现了多态的扩展性与便利
 * 多态的劣势：
 * 不能使用子类的独有方法，只能强制转型后使用
 * 强制转型前要使用instanceof关键字判断变量的真实类型
 * 即判断instanceof左边的变量指向的对象真实类型是否是右边的类型或其子类
 * 是则返回true，否则返回false
 */
public class Test {
    public static void main(String[] args) {
        //后续业务行为随右边对象而改变，故后续代码无需修改
        //即将右边换成别的对象就行
        Animal dog = new Dog();
        go(dog);
        Animal tortoise = new Tortoise();
        go(tortoise);
        //修勾在看门
        uniqueMethod(dog);
        //乌龟在晒太阳
        uniqueMethod(tortoise);
    }

    /**
     * 使用父类型做参数，可接收一切子类对象
     * @param animal
     */
    public static void go(Animal animal){
        System.out.println("开始跑！");
        animal.run();
    }

    /**
     * 判断animal变量的真实类型，并调用其独有方法
     * @param animal
     */
    public static void uniqueMethod(Animal animal){
        if (animal instanceof Dog){
            ((Dog) animal).lookDoor();
        }else if (animal instanceof Tortoise){
            ((Tortoise) animal).underSun();
        }
    }
}

父类：

package com.itheima.demo08polymorphic.polymorphicadvance;

public class Animal {
    public String name = "动物名字";
    public void run(){
        System.out.println("动物都会跑");
    }
}

子类：

package com.itheima.demo08polymorphic.polymorphicadvance;

public class Dog extends Animal {
    public String name = "修勾";
    @Override
    public void run(){
        System.out.println("修勾跑得贼快");
    }
    /*
    独有功能
     */

    public void lookDoor(){
        System.out.println("修勾在看门");
    }
}

package com.itheima.demo08polymorphic.polymorphicadvance;

public class Tortoise extends Animal {
    public String name = "乌龟";
    @Override
    public void run(){
        System.out.println("乌龟属实跑不动");
    }
    /*
    独有功能
     */

    public void underSun(){
        System.out.println("乌龟在晒太阳");
    }

}

案例

测试类：

package com.itheima.demo08polymorphic.polymorphiccase;

/**
 * 案例：
 * 电脑有两个USB接口，可以接入鼠标和键盘
 * 鼠标和键盘都能接入和拔出，鼠标还能点击，键盘可以敲字
 * 请用代码实现
 */
public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        Mouse m = new Mouse("罗技鼠标");
        KeyBoard k = new KeyBoard("黑峡谷键盘");
        computer.install(m);
        computer.install(k);
    }
}

USB接口：

package com.itheima.demo08polymorphic.polymorphiccase;

public interface USB {
    void connect();
    void unconnect();
}

电脑类：

package com.itheima.demo08polymorphic.polymorphiccase;

public class Computer {
    /*
    定义一个USB安装入口
     */

    public void install(USB u){
        u.connect();
        if (u instanceof Mouse){
            ((Mouse) u).click();
        }else if(u instanceof  KeyBoard){
            ((KeyBoard) u).write();
        }
        u.unconnect();
    }
}

键盘类：

package com.itheima.demo08polymorphic.polymorphiccase;

public class KeyBoard implements USB {
    private String name;

    public void write(){
        System.out.println("写下一行情书");
    }
    public String getName() {
        return name;
    }

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

    public KeyBoard(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name + "连接成功");
    }

    @Override
    public void unconnect() {
        System.out.println(name + "已断开连接");
    }
}

鼠标类：

package com.itheima.demo08polymorphic.polymorphiccase;

public class Mouse implements USB {
    private String name;

    public Mouse() {

    }

    public void click(){
        System.out.println("双击666");
    }
    public String getName() {
        return name;
    }

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

    public Mouse(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name + "成功连接");
    }

    @Override
    public void unconnect() {
        System.out.println(name + "已断开连接");
    }
}

练习1

测试类：

package com.itheima.exercises.exercise01;

/**
 * 请使用代码描述:    
 *    奥迪车(Audi)都具有跑的功能，但是智能奥迪车(SmartAudi)除了具有跑的功能外，还具有自动泊车(automaticParking)和无人驾驶(automaticDrive)的功能！
 *    要求:使用多态形式创建对象
 */
public class Exercise01 {
    public static void main(String[] args) {
        Audi audi = new Audi();
        audi.run();
        Audi smartAudi = new SmartAudi();
        ((SmartAudi) smartAudi).automaticDrive();
        ((SmartAudi) smartAudi).automaticParking();
    }
}

奥迪车类：

package com.itheima.exercises.exercise01;

public class Audi {
    public void run(){
        System.out.println("奥迪车在行驶");
    }
}

智能奥迪车类：

package com.itheima.exercises.exercise01;

public class SmartAudi extends Audi {
    public void automaticParking(){
        System.out.println("智能奥迪车在自动泊车");
    }
    public void automaticDrive(){
        System.out.println("智能奥迪车在自动驾驶");
    }
}

练习2

测试类：

package com.itheima.exercises.exercise02;

import com.itheima.exercises.exercise02.domain.AirCondition;
import com.itheima.exercises.exercise02.domain.TV;

/**
 * 请使用代码描述:
 * 我们平时的家用电器,都需要通电,然后开启,或者关闭,而且每个家用电器都有自己特殊的功能,比如:
 * 电视,除了通电之后的开启和关闭,还有播放电视剧的功能
 * 空调,除了通电之后的开启和关闭,还有制冷的功能
 * 要求:将电视和空调的抽取出来
 */
public class Exercise02 {
    public static void main(String[] args) {
        TV t = new TV();
        t.tongdian();
        t.open();
        t.close();
        t.tvShow();
        System.out.println("===================================");
        AirCondition a = new AirCondition();
        a.tongdian();
        a.open();
        a.refrigeration();
        a.close();
    }
}

接口：

package com.itheima.exercises.exercise02.domain;

public interface Sockets {
    void tongdian();
}

电器类：

package com.itheima.exercises.exercise02.domain;

/**
 * 家用电器
 */
public abstract class Appliance implements Sockets{
    public abstract void open();
    public abstract void close();

    @Override
    public void tongdian() {
        System.out.println("通电");
    }
}

空调类：

package com.itheima.exercises.exercise02.domain;

public class AirCondition extends Appliance {
    @Override
    public void open() {
        System.out.println("打开空调");
    }

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

    public void refrigeration(){
        System.out.println("制冷");
    }
}

电视类：

package com.itheima.exercises.exercise02.domain;

/**
 * 电视类
 */
public class TV extends Appliance{
    @Override
    public void open() {
        System.out.println("打开电视");
    }

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

    public void tvShow(){
        System.out.println("播放电视剧");
    }
}

练习3

测试类：

package com.itheima.exercises.exercise03;

/**
 * 水果都能被榨成汁,在现实生活中,我们需要一个榨汁机,
 * 往榨汁机中的装什么水果就被榨成什么果汁,请根据描述设计一个程序
 */
public class Exercise03 {
    public static void main(String[] args) {
        FruitJuicing p = new Pear();
        FruitJuicing a = new Apple();
        Juicer juicer = new Juicer();
        juicer.squeez(a);
        juicer.squeez(p);
    }
}

接口：

package com.itheima.exercises.exercise03;
/**
 * 榨汁接口
 */
public interface FruitJuicing {
    void juice();
}

苹果类：

package com.itheima.exercises.exercise03;

public class Apple implements FruitJuicing {
    @Override
    public void juice() {
        System.out.println("苹果被榨成汁了");
    }
}

梨类：

package com.itheima.exercises.exercise03;

public class Pear implements FruitJuicing {
    @Override
    public void juice() {
        System.out.println("梨被榨成汁了");
    }
}

榨汁机类：

package com.itheima.exercises.exercise03;

public class Juicer {
    public void squeez(FruitJuicing fruit){
        if (fruit instanceof Apple){
            fruit.juice();
        }else if (fruit instanceof Pear){
            fruit.juice();
        }
    }
}
,请根据描述设计一个程序
 */
public class Exercise03 {
    public static void main(String[] args) {
        FruitJuicing p = new Pear();
        FruitJuicing a = new Apple();
        Juicer juicer = new Juicer();
        juicer.squeez(a);
        juicer.squeez(p);
    }
}

接口：

package com.itheima.exercises.exercise03;
/**
 * 榨汁接口
 */
public interface FruitJuicing {
    void juice();
}

苹果类：

package com.itheima.exercises.exercise03;

public class Apple implements FruitJuicing {
    @Override
    public void juice() {
        System.out.println("苹果被榨成汁了");
    }
}

梨类：

package com.itheima.exercises.exercise03;

public class Pear implements FruitJuicing {
    @Override
    public void juice() {
        System.out.println("梨被榨成汁了");
    }
}

榨汁机类：

package com.itheima.exercises.exercise03;

public class Juicer {
    public void squeez(FruitJuicing fruit){
        if (fruit instanceof Apple){
            fruit.juice();
        }else if (fruit instanceof Pear){
            fruit.juice();
        }
    }
}
时帆
关注
专栏目录
Java 继承，多态，接口练习
wangjh11234的博客
03-21 2694
Java 继承，多态，接口练习
家用电器的多态性（1）
Yurken的博客
06-06 1301
import java.util.*; abstract class equipment { public double power; public abstract double computequantity(); } class tv extends equipment { private double time; public tv(double power, doub...
Java编程题之家电思路总结
qq_24884213的博客
10-31 2251
1.编程要求 韩国某家电公司为本公司所有电器设计了一个通用的遥控器，遥控器能发送“on，off，up，down…”等信号给电器，所有电器均能接受该遥控器上的信号，并完成相应的操作。 　　现有一用户朝着电视按“开”，电视就开了，按“上”，电视音量就调大了…之后，用户朝着风扇按“开”，风扇就开了，按“上”，风扇转速就调大了… 编写： 　　家电接口（Appliance，方法：recive）、 　　电视...
js小案例：控制电灯开关
学亮编程手记
12-22 362
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <script> var flag = false;//代表关闭 function fun(){ var light = document.getElementByI.
回答家电问题代码
luning0526的博客
06-25 343
import java.util.Scanner;/*  （1）给4类家电各输入3个品牌的电器型号、价格和库存；  （2）统计每类家电的平均价格，最高价和最低价；  （3）将4类家电按平均价格降序排序；  （4）统计每类电器高于平均价格和低于平均价格的电器数量；  （5）输入电器型号查询电器的价格和库存。*/public class Eequi { public static void main(...
# Day01-Java基础
Java厂长
07-25 8047
Day01-Java 1、Java主要特点 简单性、跨平台性、分布性、安全性、健壮性、平台独立与可移植性、多线程、动态性、面向对象的编程语言、支持垃圾自动收集处理等，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用等多个系统中。 2、计算机的高级汇编语言类型： 编译型——c语言 解释型——html 编译型和解释型的结合——java java运行原理源程序进行编译形成字节码文件在一台电脑进行解释程序 java最核心的部分就是虚拟机JVM 3、JVM（Java Visual Machine)
java计算-5%3_JAVA基础教程day03--运算符
weixin_34615710的博客
02-27 3084
一、算术运算符%(取余)、前++(先运算后取值)、后++(先取值后运算)、前--(先运算后取值)、后--(先取值后运算)(1): 5%2=1(2):前++//前++int a1=10;int b1=++a1;System.out.println(b1);//b1=11(3):后++//后++int a2=-10;int b2=a2++;System.out.println("a2="+a2+",b...
PTA jmu-java-日期类的使用：制作工作日历
m0_73680520的博客
10-11 1260
7-4（选做） jmu-java-日期 想要根据给定日期及周数制作一个工作日历，具备如下3个功能。功能1: 需制作一个工作日历。给定指定日期与持续周数n，将以指定日期所在周的星期一开始，生成一个长达n周的工作日历(包括最后一会周的星期日)。输出该工作日历的起止日期及星期。功能2: 输入日期，判断该日期是否在工作日历内。如果在，则输出该日期在工作日历的第几周的星期几，离工作日历结束还剩多少周、多少天。功能3: 输入周次，可以将该周所在月的日历打印出来，并将该周的起止日期输出。如果跨月，可以将两个月的日历输出。
java建老师类学生类_day11作业------------------Java面向对象--JavaObject02-2
weixin_34201593的博客
02-24 3484
作业1. 将人，学生和老师(老师多了教工编号和讲课的行为)案例用继承实现，并添加军人类，军人的特殊属性假设有部队编号，军人特有的行为假设有训练。2.a. 声明一个Person类，里面定义了三个属性，name、gender、age(姓名、性别、年龄)通过构造方法进行赋值。有一个display方法，可以展示对应的姓名性别年龄信息b. 声明一个Student类，继承自Person类，增加一个独特的属性i...
崔希凡JavaWeb视频教程_day19-资料源码
07-13
在Day19的教程中，我们可以期待探讨更高级的主题，例如Servlets、JSP（JavaServer Pages）、过滤器（Filters）和监听器（Listeners）等。 1. **Servlets**：Servlet是Java编程语言中的一个接口，用于扩展服务器的...
崔希凡JavaWeb笔记day19-day21
10-22
### 基于崔希凡JavaWeb笔记day19-day21的知识点提炼 #### 一、BaseServlet设计思想及实现 **知识点1：BaseServlet的设计背景与意义** - **背景**：随着项目的扩大，单一的`Servlet`类数量急剧增多，这不仅增加了...
java-day2-homework-cmadisonne:GitHub Classroom创建的java-day2-homework-cmadisonne
04-29
Java_Day2_家庭作业 练习17 给定一个主要功能： printNumbers(); 创建一个printNumbers函数以打印从-25到20的整数。 练习18 给定一个主要功能： String studentName = " Kenn " printName(studentName); 创建...
java进阶超全面javaweb教程28天day1- 19 框架标签的使用
08-31
java进阶超全面javaweb教程28天day1-_19_框架标签的使用
lunar-java-master.zip
08-28
"lunar-java-master.zip" 文件包含了一个专门处理日历系统，包括公历（阳历）与农历（阴历，又称老黄历）转换的项目。本文将深入探讨Java中如何实现这些功能，并提供相关的代码示例。 首先，我们了解基础概念。公历...
工厂模式的介绍及实现
户伟伟的博客
09-25 117
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1093
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 443
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 238
BI商业智能：数据可视化、报表可视化系统。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 912
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java面试必备知识点详解
19. **调用类的方法**：通过`Class`对象的`getMethod()`或`getDeclaredMethod()`方法获取`Method`对象，再调用`invoke()`方法执行。 20. **数值型字符转换为数字**：使用`Integer.parseInt()`或`Integer.valueOf()`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值