javase复习day13_面对对象进阶_static

最新推荐文章于 2025-02-13 11:37:01 发布
最新推荐文章于 2025-02-13 11:37:01 发布
阅读量706 收藏 20
点赞数 15
分类专栏： javase复习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72625929/article/details/141825035
版权

面对对象进阶

static

工具类：

工具类的构造要求

工具类练习一：

工具类：

public  class ArrayUtil {


    //私有化构造方法
    private ArrayUtil() {
    }

    //静态方法,方便调用
    public static String printArr(int[] arr){
        String result = "";
        result = result+"[";
        for (int i = 0; i < arr.length; i++) {

           //最后一个不需要加逗号
           if (i==arr.length-1){
               result += arr[i];
           }else {
               result += arr[i] + ", ";
           }
        }
        result = result+"]";
        return result;
    }

    public static double getAerage(double[] arr){
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        double avg;
        avg = sum/arr.length;
        return avg;
    }


}

测试类：

public class TestDemo {
    public static void main(String[] args) {
        //生成一个数组
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        //调用静态方法进行验证
        System.out.println(ArrayUtil.printArr(arr));

        double[] arr2 = {1.1,2.2,3.3,4.4,55,66};
        System.out.println(ArrayUtil.getAerage(arr2));

    }
}

工具类练习二：

学生类：

//使用插件生成的javaBean类（Ptg插件）
public class Student {
    private String name;
    private int age;
    private String gender;


    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", gender = " + gender + "}";
    }
}

学生工具类：

public class StudentUtil {
    private StudentUtil() {
    }
    //工具类中的方法
    public static int MaxAge(ArrayList<Student> arr){
        int maxage = 0;
        //循环获取学生对象的年龄
        for (int i = 0; i < arr.size(); i++) {
            if (maxage < arr.get(i).getAge()){
                maxage = arr.get(i).getAge();
            }
        }
        return maxage;
    }
}

测试类：

public class TestDemo2 {
    public static void main(String[] args) {
        //创建学生对象并赋值给学生集合
//        Student[] arr = new Student[3];
        ArrayList<Student> arr = new ArrayList<>();
        Student s1 = new Student("张三",20,"男");
        Student s2 = new Student("李四",25,"男");
        Student s3 = new Student("娜娜",21,"女");

        arr.add(s1);
        arr.add(s2);
        arr.add(s3);

        //调用方法
        int i = StudentUtil.MaxAge(arr);
        System.out.println(i);
    }
}

static的注意事项：

static小结：

重识main方法

选择编辑按钮。

public class Test {
    public static void main(String[] args) {
        //String 数组的类型
        //[] 表示这是数组
        // args 数组名称
        // 在低版本的java中用于接受键盘的输入
        System.out.println(args.length);
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

运行结果：

3
hello
world
java
 

表明数组有三个String字符串组成

继承

面对对象三大特征：

封装，继承，多态。

封装：

继承

继承的学习要点

  • 如何自己写继承（自己设计）
  • 如何使用别人写的继承
什么时间用继承

继承的小结：

继承的特点

继承的特点小结

注意事项：

  • 子类只能继承父类中非私有的成员。

练习：继承练习（自己设计一个继承体系）

public class Animal {
    public  void eat(){
        System.out.println("吃饭");
    }
    public  void drink(){
        System.out.println("喝水");
    }
}
public class Cat extends Animal{
    public  void catch_mice(){
        System.out.println("抓老鼠");
    }
}
public class Dog extends Animal {
    public  void special(){
        System.out.println("看家");
    }
}
public class Ragdoll extends Cat{
}
public class Dragon_Li extends Cat {
}
public class Huskies extends Dog{
    public  void destruction(){
        System.out.println("拆家");
    }
}
public class Teddy extends Dog{
    public void coquetry(){
        System.out.println("蹭一蹭");
    }
}

public class Test {
    public static void main(String[] args) {
        Ragdoll r = new Ragdoll();
        r.eat();
        r.drink();
        r.catch_mice();
        System.out.println("====================================");
        Huskies h = new Huskies();
        h.destruction();
        h.drink();
        h.eat();
        h.special();
    }
}
子类可以继承的东西

继承的内存图

成员方法是否被继承

成员方法的继承的内存图

成员变量的访问特点：

public class Test {
    public static void main(String[] args) {
        zi z = new zi();
        z.show();
    }
}
class Fu{
    String name = "FU";
    String hobby = "喝茶";
}
class zi extends Fu{
    String name = "zi";
    String game = "吃鸡";
    public void show(){
        //打印zi
        System.out.println(this.name);
        //打印吃鸡
        System.out.println(game);
        //打印FU
        System.out.println(super.name);
        //打印喝茶
        System.out.println(hobby);
    }
}
成员方法的访问特点：

方法的重写

方法重写的本质

修改了虚方法表中的方法，如果方式重写，就会覆盖虚方法表中的方法

重写的注意事项

练习：利用方法的重写设计继承结构

public class Dog {
    public  void special(){
        System.out.println("看家");
    }
    public  void eat(){
        System.out.println("吃饭");
    }
    public  void drink(){
        System.out.println("喝水");
    }
}
public class Huskies extends Dog {
    public  void destruction(){
        System.out.println("拆家");
    }
    @Override
    public  void eat(){
        System.out.println("吃狗粮");
    }
}
public class ShaPiDog extends Dog{
    @Override
    public  void eat(){
        System.out.println("吃狗粮，吃骨头");
    }
}
public class tianYuanDog extends Dog{
    @Override
    public  void eat(){
        System.out.println("吃剩饭");
    }
}
public class Test {
    public static void main(String[] args) {
        Demo.ChongXieTest.Huskies r = new Demo.ChongXieTest.Huskies();
        r.eat();
        r.drink();
        r.eat();
        r.destruction();
        System.out.println("====================================");
        tianYuanDog h = new tianYuanDog();
        h.drink();
        h.eat();
        h.special();
        System.out.println("====================================");
        ShaPiDog s = new ShaPiDog();
        s.drink();
        s.eat();
        s.special();
    }
}
方法重写的总结：

继承中构造方法的访问特点：

public class fuClass {
    public String name;
    public int age;

    public fuClass() {
        System.out.println("父类的无参构造");
    }

    public fuClass(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("调用父类的有参构造");
    }
}
public class ziClass extends fuClass{
    public ziClass() {
        super();
        System.out.println("调用子类无参构造");
    }

    public ziClass(String name, int age) {
        super(name, age);
        System.out.println("调用子类有参构造");
    }
}

public class test {
    public static void main(String[] args) {
        ziClass z = new ziClass();
        ziClass z1 = new ziClass("小李",20);
    }
}
this和super总结

练习：带有继承结构的标准javaBean

package Test.Test1;

public class Empyee {
   private String id;
   private String name;
   private int price;

   public void work(){
       System.out.println("员工正在工作");
   }
   public void eat(){
       System.out.println("员工正在吃饭");
   }

    @Override
    public String toString() {
        return "Empyee{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    public Empyee() {
    }

    public Empyee(String id, String name, int price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

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

package Test.Test1;

public class JinLi extends Empyee {
    private int parc;

    public JinLi() {}

    public JinLi(String id, String name, int price, int parc) {
        super(id, name, price);
        this.parc = parc;
    }

    @Override
    public void work() {
        System.out.println("管理他人");
    }

    @Override
    public String toString() {
        return "JinLi{" +
                "parc=" + parc +
                '}';
    }
}

package Test.Test1;

public class Cook extends Empyee{
    public Cook() {
    }

    public Cook(String id, String name, int price) {
        super(id, name, price);
    }

    @Override
    public void work() {
        System.out.println("炒菜");
    }


}

package Test.Test1;

public class Test2 {
    public static void main(String[] args) {
        JinLi j = new JinLi("heima001","小赵",12000,8000);
        j.work();
        j.eat();
        System.out.println("“========================”");
        Cook c = new Cook();
        c.setId("www");
        c.setName("小王");
        c.setPrice(18888);
        c.work();
        c.eat();
    }
}
练习二：

public class Employee {
  private   String name;
  private String id;

  public void work(){
      System.out.println("工作");
  }

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

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

    public Employee() {
    }

    public Employee(String name, String id) {
        this.name = name;
        this.id = id;
    }
}
package Test.Test2;

public class Teacher extends Employee{
    public Teacher() {
    }

    public Teacher(String name, String id) {
        super(name, id);
    }
}

package Test.Test2;

public class AdminStaff extends Employee{
    public AdminStaff() {
    }

    public AdminStaff(String name, String id) {
        super(name, id);
    }
}

package Test.Test2;

public class Lectuer extends Teacher{
    @Override
    public void work() {
        System.out.println("讲师工作");
    }

    public Lectuer() {
    }

    public Lectuer(String name, String id) {
        super(name, id);
    }
}

package Test.Test2;

public class Tutor extends Teacher{
    @Override
    public void work() {
        System.out.println("助教工作");
    }

    public Tutor() {
    }

    public Tutor(String name, String id) {
        super(name, id);
    }
}

package Test.Test2;

public class Maintainer extends AdminStaff{
    @Override
    public void work() {
        System.out.println("维护专员工作");
    }

    public Maintainer() {
    }

    public Maintainer(String name, String id) {
        super(name, id);
    }
}

package Test.Test2;

public class Buyer extends AdminStaff{
    @Override
    public void work() {
        System.out.println("采购专管员工作");
    }

    public Buyer() {
    }

    public Buyer(String name, String id) {
        super(name, id);
    }
}

package Test.Test2;

public class Test {
    public static void main(String[] args) {
        Lectuer l = new Lectuer("小李","heima111");
        l.work();

        Maintainer m = new Maintainer();
        m.work();
    }
}

课后练习

第一题

第一题：

需求：

在黑马程序员中有很多员工(Employee)。

按照工作内容不同分教研部员工(Teacher)和行政部员工(AdminStaff)

  1. 教研部根据教学的方式不同又分为讲师(Lecturer)和助教(Tutor)

  2. 行政部根据负责事项不同,又分为维护专员(Maintainer),采购专员(Buyer)

  3. 公司的每一个员工都编号,姓名和其负责的工作

  4. 每个员工都有工作的功能，但是具体的工作内容又不一样。

答案同上。

第二题：

第二题：

需求：

在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。

分析：

学生信息和行为（名称，年龄，所在班级，查看课表，填写听课反馈fillForm）

老师信息和行为（名称，年龄，部门名称，查看课表，发布问题publishForm）

定义角色类作为父类包含属性（名称，年龄），行为（查看课表）

定义子类：学生类包含属性（所在班级），行为（填写听课反馈）

定义子类：老师类包含属性（部门名称），行为（发布问题）

package Test.workTest2;

public class User {
    private String name;
    private int age;

    public void look(){
        System.out.println("查看课表");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Teacher extends User{
    //部门名称
    private String workname;

    public void work(){
        System.out.println("发布问题");
    }

    public String getWorkname() {
        return workname;
    }

    public void setWorkname(String workname) {
        this.workname = workname;
    }

    public Teacher(String workname) {
        this.workname = workname;
    }

    public Teacher(String name, int age, String workname) {
        super(name, age);
        this.workname = workname;
    }
}

class student extends User{
    private String classname;

    public void leanclass(){
        System.out.println("填写上课反馈");
    }

    public String getClassname() {
        return classname;
    }

    public void setClassname(String classname) {
        this.classname = classname;
    }

    public student(String classname) {
        this.classname = classname;
    }

    public student(String name, int age, String classname) {
        super(name, age);
        this.classname = classname;
    }
}

package Test.workTest2;

public class Test {
    public static void main(String[] args) {
        student s = new student("小李",18,"后端一期");
        System.out.println(s.getClassname());
        s.leanclass();
        s.look();

        System.out.println("====================");
        Teacher t = new Teacher("老王",40,"教学部");
        System.out.println(t.getWorkname());
        t.look();
        t.work();
    }
}

第三题：

第三题：

需求:

完成代码(按照标准格式写)，然后在测试类中测试。

1.手机类Phone

属性:品牌brand,价格price

无参构造,有参构造

行为:打电话call,发短信sendMessage,玩游戏playGame

2.测试类

创建Phone类对象,调用Phone类中的方法

思考:

假设所有的手机都有属性屏幕的尺寸(int size),而且假设所有手机的屏幕尺寸为6,应该如何实现?

提示：

可以把size定义为静态

package Test.Test3;

public class Phone {
    private String brand;
    private int price;

    public static int size;

    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }


    public String getBrand() {
        return brand;
    }

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

    public int getPrice() {
        return price;
    }

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

    public Phone(String brand, int price) {
        this.brand = brand;
        this.price = price;
        this.size = 6;
    }

    public Phone() {
        this.size = 6;
    }

    public static int getSize() {
        return size;
    }

    public static void setSize(int size) {
        Phone.size = size;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "brand='" + brand + '\'' +
                ", price=" + price + "xiae:"+
                size+
                '}';
    }
}

package Test.Test3;

public class Test {
    public static void main(String[] args) {
        Phone p = new Phone();
        System.out.println(p);
        p.call();
        p.sendMessage();
        p.playGame();
    }
}

Java知识点汇总--基础篇
m0_74194490的博客
07-01 4008
异常就是程序在运行时出现的意外情况，而导致程序无法正常往下执行[终止了]当系统提供的异常类型无法满足客户需求时，程序员可以自己定义异常类型。目的可以达到见名知意创建一个异常类并继承RuntimeException//创建一个构造函数super(msg);使用自定义的异常类。
最新大数据24期+ 共十天+ 附课件源码（完整）
weixin_44654984的博客
03-02 2224
下载地址：百度网盘 课程目录： 大数据24期-01-JavaSE基础-15天 第一天： 01.什么是计算机软件 02.什么数据软件开发--利用编程语言来写剧本 03.什么是jdk--怎么安装jdk 03.什么是jdk--怎么安装jdk 04.安装启动eclipse 04.安装启动eclipse 05.配置eclipse的字体和布局 06.新建一个java的类的步骤 07.第一个java...
JavaSE学习进阶 day1_01 static关键字和静态代码块的使用
我的博客
03-01 427
JavaSE学习进阶 day1_01 static关键字和静态代码块的使用
【JavaSE】复习（进阶）
北极星的博客
02-26 887
java进阶知识
javase复习day22集合进阶
m0_72625929的博客
09-10 794
栈、队列、数组、链表、二叉树、二叉查找树、平衡二叉树、红黑树。添加数据时会有一个size指针，表示当前集合的数量又指定先一个元素的位置。
JavaSE复习之网络编程（Days26）
yuanmomoya的博客
08-19 984
JavaSE之网络编程复习（Day26）   javaSe基础中的网络编程算是学习javaEE的选学内容。但是多学点总是没有坏处，也增加些对网络方面的了解，当然对于大学学习计算机专业的学生来说，这些基础知识就太基础了。   学习网络编程要用到IO流的知识，毕竟涉及到文件或者字符的传输！！   网络编程的学习大纲： 网络通讯的相关概念 InretAddress类的使用 基于TCP的...
JavaSE Notes.doc
01-06
### day12 - day15, day13 - day16, day17 - day18 - 未提供具体内容 这些章节可能继续深入到高级Java特性，如并发编程、GUI编程、数据库连接、XML处理、JDBC等。 ### day19 - 未提供具体内容 这部分可能包含最后的...
网易日常实习一面面经
cc0319cc的博客
02-11 830
tail 是一个非常实用的命令，特别适用于日志文件的查看和实时监控。
【SpringBoot实现全局API限频】 最佳实践
weixin_42430947的博客
02-10 757
SpringBoot 实现全局API限频，推荐一个结合 拦截器 + Redis 的分布式解决方案
探索 JavaScript 中的“影子世界”：引用（Reference）的奥秘
大葱的田地🌱
02-13 637
你是否曾在 JavaScript 中修改了一个变量，却发现另一个变量也“神秘”地发生了变化？或者明明两个数组看起来一模一样，却无法通过 === 比较？这一切的背后，都是 引用（Reference） 在“搞鬼”！ 在这篇博客中，我们将揭开 JavaScript 中引用的神秘面纱，带你深入理解它的工作原理，并教你如何避免常见的“引用陷阱”。无论你是初学者还是经验丰富的开发者，这篇文章都会为你提供实用的技巧，让你的代码更加健壮和高效。准备好了吗？让我们一起进入 JavaScript 的“影子世界”吧！
java面向对象进阶
m0_74825526的博客
02-12 267
成员变量也称为属性。Java中的成员变量分为类属性和实例属性两种，定义属性时没有static修饰符修饰的就是实例属性。而实例属性则从类的实例被创建起开始存在，直到系统销毁该实例，实例属性的作用域与其对应的实例的生命周期相同。静态成员变量是被static关键字修伤的成员变量，静态成员变量属于其所在类，被类中的所有实阴共享，静态成员变量可通过类直接访问，也可通过类的实例访问。使用成员方法和成员属性时，可以使用“this.方法(参数列表)”和“this.成员属性”，分别调用当前对象的方法和成员属性。
JAVA简单实现一个布隆过滤器
最新发布
有时间就写写代码
02-13 622
布隆过滤器是一种非常高效的概率型数据结构，适合用在对空间和时间有严格要求的场景中，尤其是那些允许有少量误报的情况。通过减少内存消耗，它能够在海量数据处理时提供极大的性能优势。不过，它的缺点是有一定的误判率，且不能删除已加入的元素，因此在设计时需要根据应用场景调整哈希函数数量和位数组的大小。
Java进阶面试题（网上资料整理）
m0_74825614的博客
02-12 384
考虑一个类 A 有 foo() 方法, 然后 B 和 C 派生自 A, 并且有自己的 foo() 实现，现在 D 类使用多个继承派生自 B 和C，如果我们只引用 foo(), 编译器将无法决定它应该调用哪个 foo()。由于接口只有方法声明而且没有提供任何实现，因此只有一个特定方法的实现，因此不会有任何歧义。假设你需要多重继承的情况并不多，简单起见，明智的决定是省略它。此外，Java 可以通过。多重继承确实使设计复杂化并在转换、构造函数链接等过程中产生问题。钻石形继承问题产生的歧义。
spring如何解决循环依赖？
cccfire的博客
02-13 280
代码入口可以看spring源码getBean方法，大致流程。A类依赖B B又依赖A (A->B->A)
（04）JavaScript 中 Object的属性详解
鱼遇海
02-11 686
以上是 JavaScript 中对象的核心方法和属性。返回对象的字符串表示。创建一个新对象，使用现有对象作为新对象的原型。类型的主要方法、属性和示例。冻结对象，禁止修改属性、添加或删除属性。检查属性是否为对象自身的（非继承的）。返回对象自身可枚举属性的键值对数组。检查对象是否在另一个对象的原型链上。合并源对象的可枚举属性到目标对象。返回对象自身可枚举属性的键名数组。：检查属性是否在对象或其原型链中。返回对象自身可枚举属性的值数组。访问或设置对象的原型（推荐使用。定义或修改对象的属性特性（如。
数据脱敏方案总结
2401_86844317的博客
02-12 562
/输出：4110************21。//输出：6217 **** **** *** 5666。注意：Hutool 脱敏是通过 * 来代替敏感信息的，具体实现是在 StrUtil.hide 方法中，如果我们想要自定义隐藏符号，则可以把 Hutool 的源码拷出来，重新实现即可。//输出：****************现在有了数据脱敏工具类，如果前端需要显示数据数据的地方比较多，我们不可能在每个地方都调用一个工具类，这样就显得代码太冗余了，那我们如何通过注解的方式优雅的完成数据脱敏呢？
船运物流管理系统
shaoweijava的博客
02-11 302
基于SpringBoot的船运物流管理系统，系统包含两种角色：管理员、用户,系统分为前台和后台两大模块
JAVA高级工程师-面试经历（含面试问题及解答）
web_13233421436的博客
02-12 955
经过了几个公司的面试，谈谈我这次找工作的面试经历。工作快五年了，所以给自己定位是找一份Java高级工程师的工作。由于疫情原因基本都是先电话面试（PS:更多的原因是me在上海，想要找重庆或成都的工作）。再废话一句，今年真的能不换工作就不换工作吧，因为基本都会被面试官压制。Java高级工程师的岗位对应聘者的任何一门技术都必须要求知晓其原理，并能够针对性的提出相应的改进方案。
C++ Primer 简单语句
m0_56279421的博客
02-11 1027
专栏简介：本专栏主要面向C++初学者，解释C++的一些基本概念和基础语言特性，涉及C++标准库的用法，面向对象特性，泛型特性高级用法。通过使用标准库中定义的抽象设施，使你更加适应高级程序设计技术。希望对读者有帮助！
Jackson序列化中的@JsonInclude使用技巧
2501_90323865的博客
02-13 345
在上述代码中，phones字段被标记为@JsonInclude(JsonInclude.Include.NON_NULL)，但其getter方法被标记为@JsonInclude(JsonInclude.Include.USE_DEFAULTS)。其中，@JsonInclude注解是控制对象序列化行为的重要手段。此时，phones字段的序列化行为遵循字段级别的@JsonInclude(JsonInclude.Include.NON_NULL)规则，由于phones不是null，因此被序列化为一个空数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值