程序员经验分享-hwhale

《Java核心技术卷1》

2023-05-16

第3章 Java的基础程序设计结构

整型

在这里插入图片描述
在这里插入图片描述
用int类型表示一百万可以这么写（since 1.7）

int a = 1_000_000;
System.out.println(a);//1000000

可用0b或0B表示二进制（同样since 1.7）

byte a = 0b0000_0010;
System.out.println(a);//2

如出现：

byte a = (byte) 200;
System.out.println(a);//-56

因200超出byte最大整数范围[-128,127]，所以将200的二进制截取后8位（这个是编码方式决定的，Java中正数用源码表示，负数用补码表示，第一位是符号位。），出现结果；

浮点型

在这里插入图片描述
在这里插入图片描述

自动（隐性）类型转换

在这里插入图片描述

运算优先级

在这里插入图片描述
在这里插入图片描述

String

检测两个字符串是否相等，且不区分大小写

System.out.println("HELLO".equalsIgnoreCase("hello"));//true

输入输出

三种获取键盘输入方法：

		//方式1：使用Scanner类（还是这个简单好用）
        Scanner in = new Scanner(System.in);
        System.out.println("输入你的名字");
        String name = in.nextLine();
        System.out.println("输入你的年龄");
        int age = in.nextInt();
        System.out.println("输入你的工资");
        float salary = in.nextFloat();
        System.out.println(name + " " + age + " " + salary);

        //方式2：直接接收
        System.out.println("Enter : ");
        byte[] bytes = new byte[1024];
        int len = System.in.read(bytes);
        System.out.println("Result : " + new String(bytes,0,len));

        //方法3：in流 ->包装流 -> 字符流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter : ");
        String str = br.readLine();
        System.out.println("Result : " + str);
        if (br != null){
            br.close();
        }

格式化输出

System.out.printf("%7.2f",222.333);// 222.33

共输出7个字符，1个空格 + 3个2 + 1个. + 2个3

System.out.printf("%tT",new Date());//00:32:49

格式化输出时间：
在这里插入图片描述
在这里插入图片描述

循环

在这里插入图片描述
可以说for循环是while循环的一种简写方式

switch循环中case
在这里插入图片描述
以及Character， Byte， Short， Integer

多维数组

//自动遍历多维数组
int[][][] a = new int[][][]{
                {
                    {1,2},{3,4}
                },
                {
                    {4,5},{6,7}
                 },
        };
System.out.println(Arrays.deepToString(a));//[[[1, 2], [3, 4]], [[4, 5], [6, 7]]]

所谓"多维数组"就是数组里的元素在引用其他数组
在这里插入图片描述

第4章 对象与类

静态方法

可以通过实例对象调用静态方法，但不推荐，因为容易造成混淆；一律用类名调用

Java中参数总是按值传递的，使用情况如下

在这里插入图片描述

构造器：

编写类时应当提供一个默认的构造器（不带参数的构造器），保证所有域被赋予默认值
数值类型数据设置为0；布尔类型数据设置为false；String等对象类型将设置为null

在构造器中调用this（即另一个构造器时），应当放在第一句，这样对于公共的构造器代码部分只需编写一次

类设计技巧

  1. 一定要保证数据私有
  2. 一定要对数据初始化
  3. 不要在类中使用过多的基本类型
  4. 不是所有的域都需要独立的域访问器和域更改器
  5. 将职责过多的类进行分解
  6. 类名和方法尽量体现它们的职责
  7. 优先使用不可变的类

第5章 继承

在这里插入图片描述
在这里插入图片描述
测试代码如下：

Parent类

public class Parent {
    @Override
    public String toString() {
        return "Parent{}";
    }
}

Child类

public class Child extends Parent{
    @Override
    public String toString() {
        return "Child{}";
    }
}

Employee类

public class Employee {
    public Parent getParent(){
        return new Parent();
    }
}

Manager类

public class Manager extends Employee{
    @Override
    public Child getParent() {
        return new Child();
    }
}

测试

    public static void main(String[] args) {
        Manager manager = new Manager();
        Employee employee = new Employee();
        System.out.println(manager.getParent());//Child{}
        System.out.println(employee.getParent());//Parent{}
    }

得出结论：允许子类将覆盖方法的返回类型定义为父类被覆盖方法原返回类型的子类！！！重写方法的返回类型并不是一定不能修改

equals方法规范

在这里插入图片描述

注意点

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

下图重写equals方法

重写equals、hashCode、toString（雇员经理例子）

Employee类

package com.cxf.EqualsHashCodeDemo;

import java.time.LocalDate;
import java.util.Objects;

public class Employee {
    private String name;
    private double salsry;
    private LocalDate hireDay;

    public Employee(String name,double salsry,int year,int month,int day){
        this.name = name;
        this.salsry = salsry;
        hireDay = LocalDate.of(year,month,day);
    }

    public String getName() {
        return name;
    }

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

    public double getSalsry() {
        return salsry;
    }

    public void setSalsry(double salsry) {
        this.salsry = salsry;
    }

    public LocalDate getHireDay() {
        return hireDay;
    }

    public void setHireDay(LocalDate hireDay) {
        this.hireDay = hireDay;
    }

    public void raiseSalary(double byPercent){
        double raise = salsry * byPercent / 100;
        salsry += raise;
    }

    @Override
    public boolean equals(Object otherObject) {
        if (this == otherObject) return true;
        if (otherObject == null || getClass() != otherObject.getClass()) return false;
        Employee other = (Employee) otherObject;
        return Objects.equals(name,other.name) && salsry == other.salsry
                && Objects.equals(hireDay,other.hireDay);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, salsry, hireDay);
    }

    @Override
    public String toString() {
        return getClass().getName() + "Employee{" +
                "name='" + name + '\'' +
                ", salsry=" + salsry +
                ", hireDay=" + hireDay +
                '}';
    }
}

Manager类

package com.cxf.EqualsHashCodeDemo;


public class Manager extends Employee {

    private double bonus;

    public Manager(String name, double salsry, int year, int month, int day) {
        super(name, salsry, year, month, day);
        bonus = 0;
    }

    public double getSalary() {
        double baseSalary = super.getSalsry();
        return baseSalary + bonus;
    }

    public void setBonus(double bonus){
        this.bonus = bonus;
    }

    @Override
    public boolean equals(Object otherObject){
        if (!super.equals(otherObject)) return false;
        Manager other = (Manager) otherObject;
        return bonus == other.bonus;
    }

    @Override
    public int hashCode() {
        return super.hashCode() + 17 * new Double(bonus).hashCode();
    }

    @Override
    public String toString(){
        return super.toString() + "[bonus=" + bonus + "]";
    }
}

测试

package com.cxf.EqualsHashCodeDemo;

public class EqualsTest {
    public static void main(String[] args) {
        Employee emp1 = new Employee("Lucy",75000,1987,12,15);
        Employee emp2 = emp1;
        Employee emp3 = new Employee("Lucy",75000,1987,12,15);
        Employee bob = new Employee("Bob",50000,1989,10,1);

        System.out.println("emp1 == emp2: " + (emp1 == emp2));
        System.out.println("emp1 == emp3: " + (emp1 == emp3));
        System.out.println("emp1.equals(emp3): " + (emp1.equals(emp3)));
        System.out.println("emp1.equals(bob): " + (emp1.equals(bob)));
        System.out.println("bob.toString(): " + bob.toString());

        Manager man1 = new Manager("Tom",80000,1987,12,15);
        Manager boss = new Manager("Tom",80000,1987,12,15);
        boss.setBonus(5000);
        System.out.println("============================================================");
        System.out.println("boss.toString(): " + boss);
        System.out.println("man1.equals(boss): " + man1.equals(boss));
        System.out.println("emp1.hashCode(): " + emp1.hashCode());
        System.out.println("emp3.hashCode(): " + emp3.hashCode());
        System.out.println("bob.hashCode(): " + bob.hashCode());
        System.out.println("man1.hashCode(): " + man1.hashCode());
    }
}

利用反射分析类的能力

package com.cxf.reflectionDemo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;

/**
 * 用于打印一个类的全部信息
 * @author chen
 * @version 1.1 2019.9.27
 */
public class ReflectionTest {
    public static void main(String[] args) {
        //键入全限定类名
        String name;
        Scanner in = new Scanner(System.in);
        System.out.println("Enter class name:(eg : java.util.Date)");
        name = in.next();

        try {
            Class c1 = Class.forName(name);
            Class superc1 = c1.getSuperclass();
            String modifiers = Modifier.toString(c1.getModifiers());
            if (modifiers.length() > 0) System.out.print(modifiers + " ");
            System.out.print("class" + " " + name);
            if (superc1 != null && superc1 != Object.class) System.out.print(" " + "extends" + " " + superc1.getName());
            System.out.print("\n{\n");
            printConstructors(c1);
            System.out.println();
            printMethods(c1);
            System.out.println();
            printFields(c1);
            System.out.println("}");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }

    /**
     * 打印一个类的全部构造方法
     * @param c1 一个类
     */
    private static void printConstructors(Class c1) {
        Constructor[] constructors = c1.getDeclaredConstructors();

        for (Constructor c : constructors) {
            String name = c.getName();
            System.out.print("  ");
            String modifiers = Modifier.toString(c.getModifiers());
            if (modifiers.length() > 0) System.out.print(modifiers + " ");//修饰名
            System.out.print(name + "(");//方法名
            //参数类型
            Class[] paramTypes = c.getParameterTypes();
            for (int j = 0; j < paramTypes.length; j++) {
                if (j > 0) System.out.print(",");
                System.out.print(paramTypes[j].getName());
            }
            System.out.print(")");
            System.out.println();

        }
    }

    /**
     * 打印一个类的全部方法
     * @param c1 一个类
     */
    private static void printMethods(Class c1) {
        Method[] declaredMethods = c1.getDeclaredMethods();

        for (Method m : declaredMethods) {
            Class returnType = m.getReturnType();
            String name = m.getName();
            System.out.print("  ");
            String modifiers = Modifier.toString(m.getModifiers());
            if (modifiers.length() > 0) System.out.print(modifiers + " ");//修饰名
            System.out.print(returnType.getName() + " " + name + "(");//返回类型,方法名
            //参数类型
            Class[] parameterTypes = m.getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                if (j > 0) System.out.print(",");
                System.out.print(parameterTypes[j].getName());
            }
            System.out.print(")");
            System.out.println();
        }
    }

    /**
     * 打印一个类的所有属性
     * @param c1 一个类
     */
    private static void printFields(Class c1) {
        Field[] fields = c1.getFields();

        for (Field f : fields) {
            Class type = f.getType();
            String name = f.getName();
            System.out.print("  ");
            String modidfier = Modifier.toString(f.getModifiers());
            if (modidfier.length() > 0) System.out.print(modidfier + " ");
            System.out.print(type.getName() + " " + name + ";");
            System.out.println();
        }
    }
}

第6章 接口、lambda表达式和内部类

对接口提供泛型，尽量杜绝“强转”

在这里插入图片描述

第7章 异常、断言和日志

在这里插入图片描述
在这里插入图片描述

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

核心技术卷

《Java核心技术卷1》 的相关文章

随机推荐

  • vim 中批量添加注释（块选择模式）

    批量注释 xff1a Ctrl 43 v 进入块选择模式 xff0c 然后移动光标选中你要注释的行 xff0c 再按大写的 I 进入行首插入模式输入注释符号如 或 xff0c 输入完毕之后 xff0c 按两下 ESC xff0c Vim 会

  • 在github找到指定版本代码并下载

    以MPC HC代码为例子 记下过程 备忘 具体版本为nightly 1 7 0 154 1 通过官网http mpc hc org downloads 找到github地址https github com mpc hc mpc hc 2 通

  • 光盘自动运行程序的秘密

    光盘自动运行程序的秘密 光盘一放入光驱就会自动被执行 xff0c 主要依靠两个文件 xff0c 一是光盘上的 Cdvsd vxd 会随时侦测光驱中是否有放入光盘的动作 xff0c 如果有的话 xff0c 便开始寻找光盘根目录下的AutoRu

  • mysql生成不重复随机数(unique number generation)

    问题来源 业务中有时会遇到要生成不重复随机数的情况 xff0c 例如 xff0c 新生成一个商品编号 房间编号 或者其他物品编号等 不愿意采用表的自增索引 id xff0c 同时又希望新生成的编号是不重复的 这就需要考验mysql的随机数功

  • 【2015/IE】Variational Autoencoder based Anomaly Detection using Reconstruction Probability

    原文首发于个人站点 xff1a 基于变分自编码器重构概率的异常检测模型 个人公众号 xff1a DreamHub 文章链接 xff1a Variational Autoencoder based Anomaly Detection usin

  • 计算机视觉：相机模型与参数标定

    一 相机投影模型 1 小孔成像 2 相机模型中的四个平面坐标系 3 像主点偏移 4 畸变现象与内参矩阵 5 外参矩阵 二 相机标定 xff1a 张正友棋盘格标定法 1 张正友棋盘格标定法描述 2 计算外参和内参 2 1 计算单应性矩阵H 2

  • 电子信息专业英语

    61 61 61 61 61 61 61 61 61 61 普通电子类 名词 1 diode 英 39 da d n 电子 二极管 2 oscillator 英 39 s le t r n 电子 振荡器 xff1b 摆动物 xff1b 动摇

  • 计算机视觉中的MAP的理解（mean average precision）

    计算机视觉中的MAP的理解 xff08 mean average precision xff09 精准率 Precision xff0c P值 和召回率 Recall xff0c R值 下面我们来讲AP xff08 average prec

  • 机器学习方法原理及编程实现--07.隐马尔科夫及其在卡尔曼滤波中的应用

    文章列表 1 机器学习方法原理及编程实现 01 K近邻法 实现MNIST数据分类 2 机器学习方法原理及编程实现 02 决策树 3 机器学习方法原理及编程实现 03 朴素贝叶斯分类器 实现MNIST数据分类 4 机器学习方法原理及编程实现

  • 安装realsense出现的一些问题

    借鉴代码 xff1a Ubuntu18 04安装librealsense2 SDK Linux 考高分网 报错 xff1a 之前安装的时候老是提示找不到realsense2 camera那几个包 xff0c 但是他就在 ros里面 xff0

  • Java程序员必读的10本书籍

    以下列出了10本书 xff0c 对于任何希望提高Java知识和理解的Java程序员来说都是必不可少的 如果你是一名程序员 xff0c 想知道如何提高你对Java的了解或者成为更好的Java开发人员 xff0c 那你就来对地方了 在本文中 x

  • ros基础必看之各个frame的理解

    文章目录 常见的坐标系坐标系的约定坐标系变换的计算Map之间的切换添加 如果觉得好请收藏点赞 frame id xff1a 用来告诉你 xff0c 发布的数据是来自哪一个坐标系的 ros中常见的坐标系 转载链接 现在小车进行移动 如图 1

  • 嵌入式 Rust 之书---第一章 引言

    目录 谁适合使用嵌入式Rust 范围 本书适用于谁 如何使用本书 为本书作贡献 1 1 了解你的硬件 1 2 一个no std的Rust环境 1 3 工具 1 4 安装工具 1 4 1 Linux 1 4 2 macOS 1 4 3 Win

  • 质心跟踪算法

    质心跟踪算法依赖于 xff08 1 xff09 现有对象质心 xff08 即 xff0c 质心跟踪器之前已经看到的对象 xff09 与 xff08 2 xff09 视频中后续帧之间的新对象质心之间的欧几里得距离 质心跟踪算法的主要假设是一个

  • 为什么我要刷leetcode!

    从今天开始我会每天坚持刷leetcode 为什么要这么做呢 xff1f 其实也是闲的哈哈哈哈 xff0c 被病毒困在家里那里也去不了 xff0c 那就不如来刷代码吧 xff01 其实不管是C 43 43 还是C还是java等各种各样的计算机

  • 标准模板库学习（5）----算法之非修正序列算法

    算法是STL的中枢 xff0c STL提供了算法库 xff0c 算法库都是模板函数 xff0c 主要分为四类 xff0c 非修正序列算法 修正序列算法 排序算法和数值算法 本文介绍非修正序列算法 adjacent find start en

  • Ubuntu中apt update和upgrade的区别

    原文链接 xff1a https blog csdn net CSDN duomaomao article details 77802673 简要说明 xff1a apt update xff1a 只检查 xff0c 不更新 xff08 已

  • Java中的信号量（Semaphore）

    初识Semaphore 信号量 xff0c 也可以称其为 信号灯 xff0c 它的存在就如同生活中的红绿灯一般 xff0c 用来控制车辆的通行 在程序员眼中 xff0c 线程就好比行驶的车辆 xff0c 程序员就可以通过信号量去指定线程是否

  • USB 2.0_ser!或者U232-P9 型USB转串Win7 32位或64位驱动 以及 USB转串串口序号查看和设置

    前几天叫同事在电脑城买了个USB转串数据线 xff0c 但是回来后在网上找了很多驱动都不行 觉得这个问题花了不少时间的 xff0c 我也拆开了 xff0c 打算按照芯片型号找驱动 xff0c 但是看不到芯片型号 现在终于找到合适的了 把这个

  • 《Java核心技术卷1》

    第3章 Java的基础程序设计结构 整型 用int类型表示一百万可以这么写 xff08 since 1 7 xff09 span class token keyword int span a span class token operato

热门标签