博学谷：Java基础知识精讲学习笔记——DAY 1

1.IDEA项目目录详情

2. IDEA基本配置

​ ①设置字体：File—>Settings—>Editor—>Font

​ ②设置配色方案：File—>Settings—>Editor—>Colors Scheme

​ ③设置编码：File—>Settings—>Editor—>File Encodings

​ 都要设置成UTF-8

​ ④隐藏不需要的文件：File—>Settings—>Editor—>File Types

​ ⑤显示/隐藏工具条和工具按钮：View—>Toolbar、View—>Tool Buttons

3.IDEA常用快捷键

快捷键	简介
Ctrl+B	进入光变所在的方法/变量的接口或是定义处，等效于Ctrl+左键单击
Ctrl+D	复制光标所在行或复制选择内容，并把复制内容插入光标位置下面
Ctrl+Y	删除光标所在行或删除选中的行
Ctrl+N	通过类名定位文件
Ctrl+F	再当前文件进行文本查找
Ctrl+/	注释光标所在行的代码
Ctrl+Alt+L	格式化代码，可以对当前文件和整个包目录使用
Ctrl+Alt+左方向键	返回到上一个操作的地方
Ctrl+Alt+右方向键	前进到下一个操作的地方
Alt+Shift+上下箭头	移动当前代码行

4. Java语言编码规范

​ ①大括号成对、对齐写（对齐：左括号前为类名+空格，右括号与类访问权限修饰关键词的第一个字母对齐）

​ ②左大括号 { 前有空格

​ ③代码缩进（前有左大括号，则下一行一定要有一个缩进）

​ ④方法和程序块之间要有空格

​ ⑤并排语句加空格（空格要加在分号后）

​ ⑥运算符左右要加空格

5. Java的注释

①单行注释：//注释文字

②多行注释：

③文档注释：*

6.数据类型转换

​ 类型转换的分类：

• 自动（隐式）类型转换

  ​ 小类型转换为大类型，自动提升为大类型

• 强制（显式）类型转换

  ​ 手动将大类型转换为小类型，运算结果是小类型

  默认的整型是int,默认浮点型是double。

注意事项：当且仅当大类型数据可以转换为小类型数据时，才进行转换，否则会造成精度损失。

7. this关键字

​ 当成员变量和局部变量重名时，可以通过this解决。添加this就代表成员变量了。

8.标准代码：JavaBean

​ Java语言编写类的标准规范。符合JavaBean标准的类，必须是具体的、公共的，并且具有无参数的构造方法，提供用来操作成员变量的set和get方法。

​ Java中封装的概念：将一系列相关事务共同的属性和行为提取出来，放到一个类中，隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

​ 封装的关键：绝对不能让类中的方法直接访问其他类的数据（属性），程序仅通过对象的方法与对象的数据进行交互。

package cn.itcast.demo1;


public class Student {
    //成员变量全部用private修饰
    //姓名
    private String name;
    //年龄
    private int age;

    //要有无参构造方法以及全参构造方法
    //无参构造方法
    public Student() {}
    //全参构造方法
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    //要提供公共的访问方式，即getXXX()及setXXX()方法
    //设置姓名

    public void setName(String name) {
        this.name = name;
    }
    //获取姓名

    public String getName() {
        return name;
    }

    //设置年龄

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

    //获取年龄

    public int getAge() {
        return age;
    }
}

package cn.itcast.demo1;

public class TestStudent {
    public static void main(String[] args) {
        //需求1:通过空参创建对象
        Student student1=new Student();
        student1.setName("学生1");
        student1.setAge(22);
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        //需求2：通过全参创建对象
        Student student2=new Student("学生2",18);
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
    }
}

9. Java常用工具——API

​ Application Programming Interface,应用程序编程接口，这里指的是API文档，通常叫”Java文档“，是Java中提供的类的使用说明书。

​ Java中组件的层次结构：模块（module）—— 包（package）—— 类或接口（class/interface）

​ 什么是模块？

​ module，自Java9起提供的一种新的Java基础组件，在包（package）的基础上又进行了一层封装，是报的容器。

API中包含两个模块：

• JavaSE Modules(Java语言的核心类库，其下的模块多以java开头。)

• JDK Modules(Java开发工具相关内容，其下的模块多以jdk开头。)

10. Object类

​ 类层次结构最顶层的基类，所有类都直接或间接地继承自Object类，所以，所有的类都是一个Object(对象)。

构造方法

• Object():构造一个对象。所有子类对象初始化时都会优先调用该方法。

成员方法（以下都是非静态类方法）

• int hashCode():返回对象的哈希码值，该方法通过对象的地址值进行计算，不同对象的返回值一般不同。
• Class getClass():返回调用此方法对象的运行时类对象（调用者的字节码文件对象）
• String toString():返回该对象的字符串表示
• boolean equals():比较两个对象是否相等

注意：java.lang包下的类不需要导入。

package cn.itcast.demo2;


public class Test {
    public static void main(String[] args) {
        //非静态方法的调用：  对象名.方法
        //1.创建Object类对象
        Object obj1 = new Object();
        Object obj2 = new Object();

        //2.测试Object类中的成员方法
        //int hashCode(): 返回对象的哈希码值,不同对象的哈希码值一般不同
        int code1 = obj1.hashCode();
        int code2 = obj2.hashCode();
        System.out.println(code1);
        System.out.println(code2);
        System.out.println("------------------");

        //Class getClass():返回调用此方法对象的运行时类对象（调用者的字节码文件对象）
        Class cls1 = obj1.getClass();
        Class cls2 = obj2.getClass();
        System.out.println(cls1);
        System.out.println(cls2);
        System.out.println("------------------");

        //String toString():返回该对象的字符串表示。默认打印的是地址值，不同对象的地址值肯定不同。
        //地址值的组成：全类名+@+哈希码值的无符号十六进制数
        String str1=obj1.toString();
        String str2=obj2.toString();
        System.out.println(str1);
        System.out.println(str2);
        System.out.println("------------------");

        //boolean equals():比较两个对象是否相等
        boolean result = obj1.equals(obj2);
        System.out.println(result);
    }
}

11.在JavaBean中重写Object类的方法

​ 开发中通常需要将对象转成字符串形式进行传输，也需要对即将使用的对象进行相等判断。因此需要定义JavaBean类，并在其中重写toString()和equals()的方法。

package cn.itcast.demo3;

public class Test {
    public static void main(String[] args) {
        //未重写toString()时，调用toString()
        //先创建一个学生类对象
        Student stu1 = new Student("学生1",21,100);
        System.out.println(stu1);//输出语句直接打印对象，默认调用该对象的toString方法


        //自定义版重写equals()方法时，调用equals()
        Student stu2 = new Student("学生1",21,100);
        System.out.println(stu2);
        System.out.println(stu2.equals(stu1));
    }
}

package cn.itcast.demo3;

import java.util.Objects;


public class Student {
    //1.定义私有属性
    private String name;
    private int id;
    private int score;

    //2.无参构造方法
    public Student() {}

    //3.全参构造方法
    public Student(String name,int id,int score) {
        this.name=name;
        this.id=id;
        this.score=score;
    }

    //4.get()＆set()方法

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

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

    public void setScore(int score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public int getScore() {
        return score;
    }

    //重写toString()方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", id=" + id +
                ", score=" + score +
                '}';
    }

    //重写equals()方法
    //1.自定义版本的equals()方法
    
    public boolean equals(Object obj) {

        Student student = (Student) obj;
        return id == student.id &&
                score == student.score &&
                name.equals(student.name);

    }
}

 

    @Override
    public boolean equals(Object o) {
        if (this == o) //比较两对象的地址值是否相同，提高效率（不需要比较属性值）
            return true;
        if (o == null || getClass() != o.getClass()) //比较是否为统一字节码文件，提高健壮性
            return false;
        Student student = (Student) o;
        return id == student.id && 
                score == student.score && 
                name.equals(student.name);
    }

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

12.Scanner类

​ 能够解析字符串（String）和基本数据类型的数据。即接受用户输入的数据。

构造方法

• Scanner(InputStream) : 构造一个扫描器对象，从指定输入流中获取数据参数System.in ,对应键盘录入

成员方法

• hashNextXxx() : 判断是否还有下一个输入项，其中Xxx可能是任意基本数据类型，返回结果为布尔类型
• nextXxx() : 获取下一个输入项，其中Xxx可能是任意基本数据类型，返回对应类型的数据
• String nextLine() : 获取下一行数据，以换行符作为分隔符
• String next() : 获取下一个输入项，以空白字符作为分隔符（空白字符：空格、tab、回车等）

package cn.itcast.demo4;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //创建scanner类对象
        //System.in 是默认的输入流，指向键盘
        Scanner sc = new Scanner(System.in);

        //接收整数
        System.out.println("请输入一个整数：n");
        //为了避免输入异常，可以加入一个判断
        if(sc.hasNextInt()) {//判断下一个录入的是否为整数，是则输出，否则提示异常
            int num = sc.nextInt();
            System.out.println("num:" + num);
        } else {
            System.out.println("您输入的不是整数。");
        }



    }
}

13.String类

​ 字符串，每一个字符串对象都是常量。

构造方法

• String(byte[]) : 构造一个String对象，将指定字节数组中的数据转化为字符串
• String(char[]) : 构造一个String对象，将指定字符数组中的数据据转化成字符串

成员方法

• boolean equals(String) : 判断当前字符串与给定字符串是否相同，区分大小写
• boolean equalsIgnoreCase(String) : 判断当前字符串与给定字符串是否相同，不区分大小写
• boolean startsWith(String) : 判断是否以给定字符串开头
• ……

package cn.itcast.demo5;

public class Test {
    public static void main(String[] args) {
        byte[] by = {97,98,99,100};
        String str = new String(by);
        System.out.println("str:"+str);
    }
}

14.StringBuilder类和StringBuffer类

​ 都是可变字符序列，用于构造字符串对象。内部使用自动扩容的数组操作字符串数据。两者使用同一个API。区别在于StringBuilder的运行效率要比StringBuffer高。

​ 构造方法

• StringBuilder() : 构造一个空的StringBuilder容器

• StringBuilder(String str) ：构造一个StringBuilder容器，并添加指定字符。

  成员方法

  • StringBuilder append(……) ：将任意数据添加到StringBuilder容器中，返回自身（返回的对象和初始对象是同一个对象）

  package cn.itcast.stringbuilderdemo;
  
  public class Test {
      public static void main(String[] args) {
          //测试空参构造方法
          StringBuilder sb = new StringBuilder();
          StringBuilder sb2 = sb.append("abc");
          System.out.println(sb2.equals(sb));
      }
  }
  

• ​ String toString() : 将当前StringBuilder容器转换为字符串

package cn.itcast.stringbuilderdemo;

public class Test {
    public static void main(String[] args) {
        //测试空参构造方法
        StringBuilder sb = new StringBuilder();
        sb.append("abc");
        System.out.println(sb);
        System.out.println("-------------------------");

        //测试带参构造方法
        //需求 ：将String类型的 “abc” 转换成StringBuilder类型
        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println(sb2);
        System.out.println("-------------------------");

        //测试成员方法
        //将三个字符串拼接成一个字符串。  加油， 努力， 哈哈哈！
        StringBuilder sb3 = new StringBuilder();
        sb3.append("加油,");
        sb3.append("努力，");
        sb3.append("哈哈哈！");
        System.out.println("sb3:" + sb3);
        System.out.println("-------------------------");
        String str = sb3.toString();
        System.out.println("字符串str:" + str);
    }
}