java简单练习 注：属性没有重写一说，属性要就近原则

已于 2023-02-04 21:41:12 修改
阅读量129 收藏
点赞数
文章标签： java 开发语言 算法
于 2023-02-03 22:59:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46511996/article/details/128861954
版权
文章展示了JAVA编程中的类设计，包括Person类的创建、冒泡排序实现，以及老师类、教授类、副教授类和讲师类的继承关系与工资计算方法。同时，提到了员工类及其子类部门经理和普通员工的工资打印功能，以及房屋出租项目的house类设计。文章强调了静态方法的使用和项目分层模式的概念。
摘要由CSDN通过智能技术生成

JAVA复习Day10 简单练习加简单项目

创建一个Person类，里面有姓名，年龄，工作，然后创建一个含有3个对象的对象数组，按照年龄进行冒泡排序，从大到小

package com.charpter08;
class Person{
    private  int age;
    private String name;
    private  String job;
    public Person(){

    }//无参构造器

    public Person(int age, String name, String job) {
        this.age = age;
        this.name = name;
        this.job = job;
    }//有参构造器

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public String getJob() {
        return job;
    }
    public String  info(){
        return "姓名:"+name+"\t年龄:"+age+"\t工作:"+job;
    }//输出信息
}
public class main {
    public static void main(String[] args) {
        Person [] person1= new Person[3];
        Person  person2= new Person();//设置一个person2用于暂时存放person的对象
        person1[0]= new Person(67,"小明","歌手");//创建对象
        person1[1]= new Person(20,"小丹","演员");//创建对象
        person1[2]= new Person(23,"小晶","医生");//创建对象
        for (int i=person1.length-1;i>1;i--){
            for (int j=i-1;j>=0;j--){
                if (person1[i].getAge()>person1[j].getAge()){
                    person2=person1[j];//这里就是实际应用
                    person1[j]=person1[i];
                    person1[i]=person2;
                }
            }
        }
        for (int i=0;i<person1.length;i++){
            System.out.println(person1[i].info());
        }//输出信息
    }
}

! 程序运行图

编写老师类，属性包括姓名，年龄，职称，基本工资
编写业务方法，实现输出一个教师的信息
编写教师类的三个子类，教授类，副教授类，讲师类没工资级别为1.3；1.2；1.1
在三个子类中都重写父类的业务方法
定义并初始化一个老师对象，调用业务方法实现对象基本信息的后台打印

在本题中的缺陷就是没有将级别归入到父类中，有待改进，

package com.charpter08.work03;
public class teacher {//父类
        private  String  name;//姓名
        private int age;
        private String post;
        private double salary;//基本工资
        public teacher(String name, int age, String post, double salary) {
            this.name = name;
            this.age = age;
            this.post = post;
            this.salary = salary;
        }//构造器
        public String  info(){
            return "姓名:"+name+"\t年龄:"+age+"\t职称:"+post+"\t工资："+salary;
        }//业务方法
    public String getName() {
        return name;
    }//由于属性为私有类，所以需要用公有方法去返回
    public int getAge() {
        return age;
    }
    public String getPost() {
        return post;
    }
    public double getSalary() {
        return salary;
    }
}

package com.charpter08.work03;
public class Professor extends  teacher {
    public Professor(String name, int age, String post, double salary) {
        super(name, age, post, salary);
    }//子类继承父类，这里需要进行父类进行构造
    private  double level=1.3;
   public String  info(){
         return "姓名:"+this.getName()+"\t年龄:"+this.getAge()+"\t职称:"+this
                 .getPost()+"\t工资："+this.getSalary()+"工资级别为："+level;
    }//输出的时候是本对象的姓名工资等
}

package com.charpter08.work03;
public class preProfessor extends  teacher {
    public preProfessor(String name, int age, String post, double salary) {
        super(name, age, post, salary);
    }//子类继承父类，这里需要进行父类进行构造
    private  double level=1.2;
    public String  info(){
        return "姓名:"+this.getName()+"\t年龄:"+this.getAge()+"\t职称:"+this
                .getPost()+"\t工资："+this.getSalary()+"工资级别为："+level;
    }//输出的时候是本对象的姓名工资等
}

package com.charpter08.work03;

public class teacher1 extends teacher {
    public teacher1(String name, int age, String post, double salary) {
        super(name, age, post, salary);
    }
    private  double level=1.1;
    public String  info(){
        return "姓名:"+this.getName()+"\t年龄:"+this.getAge()+"\t职称:"+this
                .getPost()+"\t工资："+this.getSalary()+"工资级别为："+level;
    }
}

! 程序运行图

package com.charpter08.work03;
public class works03 {
    public static void main(String[] args) {
        Professor professor = new Professor("老李",37,"教授",55.4);
        System.out.println(professor.info());
        teacher1 teacher11 = new teacher1("老刘",34,"讲师",45.7);
        System.out.println(teacher11.info());
        preProfessor preProfessor1 = new preProfessor("老白",43,"副教授",45.2);
        System.out.println(preProfessor1.info());
    }
}

父类：员工类
子类：部门经理，普通员工
部门经历工资=1000+单日工资×天数×等级
普通员工工资=单日工资×天数×等级
员工属性：姓名。单日工资，工作天数
员工方法（打印工资)
普通员工及部门经理都是员工子类，需要重新打印工资方法
定义并初始化普通员工对象，调用打印工资方法输出工资，定义并初始化部门经理对象。调用打印工资方法输入工资

package com.charpter08.work04;

public class employee {//父类
    private  String name;
    private  double salary;//每日工资
    private  int day;//工作天数
    private  double grade;//等级类型
    public void println(){
        System.out.println(name+"工资="+salary*day*grade);
    }
    public employee(String name, double salary, int day, double grade) {
        this.name = name;
        this.salary = salary;
        this.day = day;
        this.grade = grade;
    }
    public String getName() {
        return name;
    }
    public double getSalary() {
        return salary;
    }
    public int getDay() {
        return day;
    }
    public double getGrade() {
        return grade;
    }
}

package com.charpter08.work04;
public class manager extends  employee{//子类
    private  double bonus;
    //创建此对象的时候，奖金是不确定的
    public manager(String name, double salary, int day, double grade) {
        super(name, salary, day, grade);
    }
    public void pritln(){
        System.out.println("经理"+getName()+"工资="
        +(bonus+getDay()*getSalary()*getGrade()));
    }
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
}

package com.charpter08.work04;

public class work extends employee{//子类
    public work(String name, double salary, int day, double grade) {
        super(name, salary, day, grade);
    }

    public void println() {//普通员工和父类的输出工资情况一致，所以是一致的
        super.println();
    }
}

package com.charpter08.work04;

public class homework04 {
    public static void main(String[] args) {
        manager manager = new manager("刘备",100,20,1.3);
        manager.setBonus(3000);
        manager.pritln();
        work work = new work("小明",50,10,1.0);
        work.println();
    }
}

! 程序运行图

设计父类-员工类
子类：工人类，农民类，教师类，科学家类，服务生类
其中工人，农民，服务生只有基本工资
教师除基本工资外，还有课酬（元/天）
科学家除基本工资外还有年终奖
编写一个测试类，将各种类型的员工的全年工资打印出来

package com.charpter08.work05;

public class employee {//员工类
    private double salary;//基本工资
    private String name;
    private int month=12;//月份

    public employee(double salary, String name) {
        this.salary = salary;
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public String getName() {
        return name;
    }

    public int getMonth() {
        return month;
    }
    public void print(){
        System.out.println(name+"的年工资="+(month*salary));
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

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

    public void setMonth(int month) {
        this.month = month;
    }
}

package com.charpter08.work05;

public class worker extends  employee {//子类
    public worker(double salary, String name) {
        super(salary, name);
    }
    public void print() {
        System.out.println("工人的工资：");
        super.print();
    }
}

package com.charpter08.work05;

public class Peasant extends employee {//农民
    public Peasant(double salary, String name) {
        super(salary, name);
    }
    public void print() {
        super.print();
    }
}

package com.charpter08.work05;

public class teacher extends employee {//老师
    private int classday;//一年上了多少天课
    private double classmoney;//一天多少钱

    public teacher(double salary, String name) {
        super(salary, name);
    }

    public void setClassday(int classday) {
        this.classday = classday;
    }

    public void setClassmoney(double classmoney) {
        this.classmoney = classmoney;
    }
    public void print() {
        System.out.println("老师的工资：");
        System.out.println(getName()+"的年工资="+(getSalary()*getMonth()+classmoney*classday));
    }
}


package com.charpter08.work05;

public class waiter extends employee {//服务生
    public waiter(double salary, String name) {
        super(salary, name);
    }
    public void print() {
        System.out.println("服务生的工资：");
        super.print();
    }
}

package com.charpter08.work05;

public class scientist extends employee {
    private  double yearbonus;//科学家年终奖

    public scientist(double salary, String name) {
        super(salary, name);
    }

    public double getYearbonus() {
        return yearbonus;
    }
    public void setYearbonus(double yearbonus) {
        this.yearbonus = yearbonus;
    }
    public void print() {
        System.out.println("科学家的工资:");
        System.out.println(getName()+"的年工资="+((getMonth()*getSalary())+yearbonus));
    }
}

设计一个point类，其x和其y坐标可以通过构造器提供，提供一个子类，其构造器接受一个标签值和x,y坐标

package com.charpter08.work09;

public class point {//父类
    private  double x;
    private  double y;

    public point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }
}

package com.charpter08.work09;

public class pointson extends  point {
    private String  label;//特有属性
    public pointson(double x, double y) {
        super(x, y);
    }

    public String getLabel() {
        return label;
    }

    public void setLabel(String label) {
        this.label = label;
    }
    public void printl(){
        System.out.println("标签="+label+"\tx坐标="+getX()+"\ty坐标="+getY());
    }
}

package com.charpter08.work09;

public class text {
    public static void main(String[] args) {
        pointson pointson1 = new pointson(1929, 230.07);
        pointson1.setLabel("Thursday");
        pointson1.printl();
    }

}

! 程序运行图

房屋出租项目
项目设计——程序框架图（分层模式）模式的出现就是为了更加方便地管理
分层模式
简单的分层模式
简单的项目层级比较简单，后期大项目会有很多的层

当一个方法是static时，就是一个静态方法
静态方法可以直接通过类名调用

house类

package com.houserent;
/**
*house的对象表示一个房屋的信息
 */
public class house {
    //编号 房主 电话 地址 月租 状态
    private  int id;
    private  String name;
    private  String phone;
    private  String address;
    private  int rent;
    private  String state;

    public house(int id, String name, String phone, String address, int rent, String state) {
        this.id = id;
        this.name = name;
        this.phone = phone;
        this.address = address;
        this.rent = rent;
        this.state = state;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getRent() {
        return rent;
    }

    public void setRent(int rent) {
        this.rent = rent;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
    public String toString() {
        return id +
                "\t" + name +
                "\t" + phone +
                "\t" + address +
                "\t" + rent +
                "\t" + state ;
                //编号 房主 电话 地址 月租 状态
    }
}

实现功能三部曲，明确完成功能——思路分析——代码实现

m0_46511996
关注
为什么成员属性不会被重写
weixin_33979363的博客
05-12 192
本篇文章将展示一个基本的面向对象概念-属性隐藏。 Java中的成员属性能被重写吗？ 让我们先看以下代码示例，创建了两个Sub对象，并将其引用分别赋给SUb类和其父类Super； package simplejava; class Super { String s = "Super"; } class Sub extends Super { String ...
java方法重写、属性不重写的本质
逍遥云中鸟
05-06 845
引子： 类的方法重写、属性不重写，只是类加载机制的外在表现形式。 1. 混淆 /** * OverrideIntro.java分支： * 3.重写易混淆的点 */ public class OverrideConfuse{ public static void main(String[] args){ Rose rose = new Rose(); System.out.println(rose.name); rose.statement(); } } //花类 class Flow
Java学习之细节二
wjkqq0921的博客
12-07 106
属性没有重写，属性看运行类型，instanceof看运行类型
Java中属性和静态方法能被重写吗？
时空秋千的博客
04-14 1941
不能。在子类中可以定义和父类同名的变量，也可以定义和父类方法签名相同的静态方法，但这不叫重写。属性和静态方法不具有多态性。 我们先来看一下属性： class A { int i = 1; } class B extends A { int i = 2; } public class Test { public static void main(String[] args) { A a = new B(); System.out.print
java——重写
asdfg2047的博客
08-04 731
比较项位置方法名参数表返回值访问修饰符方法重写子类相同相同相同或是其子类不能比父类更严格方法重载同类相同不相同无关无关。
JAVA面向对象（下 ）（一、继承和方法重写）
m0_48677434的博客
04-18 931
必须调用的原因：父类的构造器中 编写了 为父类中声明的这些属性初始化的代码，那么子类会继承这些属性，就需要“复用”父类构造器的这些代码为它们初始化。无论在子类中调用父类的构造器，还是父类的方法，还是父类的成员变量，都要求被调用的父类成员不能是private。当子类重写了父类的某个方法，但是在子类中又要调用父类被重写的方法，就必须用“super.被重写的方法”，否则就会自己调用自己的。当父类的成员变量，与子类的成员变量重名了，可以用"super.成员变量"表示使用父类的成员变量。表示调用父类的构造器。
Java专项练习一（选择题）
MEIZE的博客
01-14 4638
1、在程序代码中写的注释太多，会使编译后的程序尺寸变大。错 解析：（注释是给人看的，只是为了方便程序员阅读理解代码，编译器不会读注释，只会读代码程序） 2、StringBuffer类对象创建之后可以再修改和变动。对 解析：（1.String对象不可变、StringBuffer对象可变的含义： 举个例子：String str = “aa”; str = “aa”+“bb”; 此时str的值为"aabb"，但是"aabb"不是在开始的字符串"aa"后面直接连接的"bb"，而是又新生成了字符串"aabb"，字符串
java面向对象(二)：继承，方法重写，final关键字，抽象类，接口
lituxiu的博客
09-27 419
1、继承 在java中，所有的类都直接或间接继承Object类，Object类称为所有Java类的祖先。java中的继承是通过extends关键字操作的。通常说被继承的类叫作父类，派生的类叫做子类，通过继承后，子类可以使用父类的成员变量和成员方法。由此特点，通常在生产中把父类设计为拥有所有子类的共同属性和行为的类，即多个类中相同的内容给提取出来定义到一个类。比如人会吃饭和睡觉，那么学生和老师也会吃饭和睡觉，如下 class Person { public void s...
JAVA面向对象之代码块 继承 方法的重写 super关键字与重写toString()方法介绍
沙漠皇帝本拉登
01-10 2732
JAVA面向对象之代码块与继承 代码块分类 局部代码块 作用:限制变量生命周期 书写位置:在方法中 构造代码块 开发中很少使用 书写位置:类中 方法外 调用时机:如果你有构造代码块 系统会帮你调用 帮你在创建对象时调用 静态代码块(一定是被static修饰) 依赖类 随着类的加载而加载 注意:只加载一次(系统只创建一次 不管你调用多少对象) 应用场景:U...
JAVA选择练习题
weixin_53334593的博客
01-23 1248
1. 现有一变量声明为 boolean aa; 下面赋值语句中正确的是 （A） A. aa=false; B. aa=False; C. aa="true"; D. aa=0; 解析：boolean的值要不是true，要不就是false。 B：开头F大写了，不对 C：=“ ”，这是一种字符串形式 D：给的是数值类型，并不属于布尔类型 2. 若有定义：byte[]x={11,22,33,﹣66}；其中0≤k≤3，则对x数组元素错误的引用是（C） A. x[5-3] B. x[k]
Java继承
weixin_45964036的博客
04-11 1163
九、内部类 内部类：将一个类定义在另一个类的内部（也是封装的一个体现） 外部类：将一个类定义在一个方法内部 public class Demo { class InnerClass{ } } Demo 是外部类， InnerClass 为内部类。 注意：Java的一个源文件中可以存放多个类，但不能成为内部类，最多只能有一个被 public 修饰，如下 public class Demo { } class Test{ } 内部类和外部类都有自
方法能重写，属性能重写吗？
junJZ_2008的专栏
01-22 595
覆写是多态的一种表现，我们平时所说的覆写一般是针对方式来说，在网上看到过有人讨论试着覆写属性，于是有点兴趣，属性真能覆写吗？回答问题之前，我们还是回忆一下方法的覆写具备哪些条件，或都说哪些方法能覆写。先回顾一下方法覆写要注意的地方：1、重载（也叫过载）时只与方法特征有关，但重写（覆写）是会进一步检查两个方法的返回类型是否相同、访问修饰权限是否缩小（假设public-&gt;protected方向是...
java属性为什么不能重写,【Simple Java】为什么成员属性不会被重写
weixin_39575850的博客
03-15 320
本篇文章将展示一个基本的面向对象概念-属性隐藏。Java中的成员属性能被重写吗？让我们先看以下代码示例，创建了两个Sub对象，并将其引用分别赋给SUb类和其父类Super；packagesimplejava;classSuper {String s= "Super";}class Sub extendsSuper {String s= "Sub";}public classQ3 {public s...
继承中关于方法重写和属性重写（覆盖）的分析
Luhuadeng的专栏
05-27 6257
Java语言中，子类继承父类的方法和属性。如果不进行重写，那么子类就直接使用父类的属性和方法。如果子类对父类的属性和方法进行了重写（也就是对属性 和 方法进行了重新的定义），那么子类就会保存两份属性和两个方法。程序可以通过子类对象访问这两个属性（父类对象的属性，子类对象的属性）；程序也可以通过子类对象调用两个方法（父类对象的方法，子类对象的方法）。 下面是代码示例： （一）父类：AutoMob...
spring循环依赖解决方式
qq_36400213的博客
11-04 923
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
最新发布
LJH_laura_li的博客
11-08 192
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 86
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 453
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
Java封装继承详解：属性保护与构造方法、重载、继承与方法重写
Java是一种广泛使用的面向对象编程语言，它的核心特性之一是封装、继承和多态。本文档主要讲解了这三个关键概念及其在实际开发中的应用。 1. **属性封装**： - **作用**: 属性封装是Java中的重要原则，它通过将类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值