【Java】基础知识笔记_java的aa=多少-CSDN博客

本文链接：https://blog.csdn.net/duckweed_code/article/details/117593628

这篇博客详细介绍了Java的基础知识，包括比特和字节的概念、代码注释的种类、自动转型规则、三元运算符的使用、位运算符的四种类型、标识符和关键字的规则、基本数据类型和引用数据类型的区别、==运算符的含义、switch语句的应用、进制转换、Scanner类获取键盘输入的方法、类的组成部分、面向对象的三大特性、方法的重载和重写、this和super关键字的用法、static关键字的作用、final关键字的三种场景、instanceof运算符的功能、包装类的定义、构造器的特性、抽象类和接口的区别、值传递机制、可变个数形参的使用、Object类的常用方法、代码块的使用、权限修饰符的四种类型、Arrays工具类的用途、子类实例化的过程以及内部类的分类及其特点。

摘要由CSDN通过智能技术生成

1.比特和字节

一个0或者一个1存储为一个比特（bit），是计算机中最小的存储单位

计算机中最基本的存储单元是字节（byte），每个字节由8个比特构成

2.代码注释

（1）单行注释：//注释内容

（2）多行注释：/* 注释内容 */

（3）文档注释：/** 注释内容 */

3.自动转型

byte、char、short —>int —>long —>float —>double

byte、char、short三种类型的变量之间做运算时，结果为int型

4.三元运算符

（条件表达式）？表达式1：表达式2（自动类型转换）

        //运行结果：9.0
        int a = 5;
        System.out.println("value is :" + ((a < 5) ? 10.9 : 9));

5.位运算符

（1）与（&）运算符，两个二进制操作数对应位同为1 结果位才为1，其余情况为0

（2）或（|）运算符，两个二进制操作数对应位只要有一个为1 结果位就为1，其余情况为0

（3）非（~）运算符，一个二进制操作数，对应位为0，结果位为1；对应位为1，结果位为0

（4）异或（^）运算符，两个二进制操作数对应位相同为0，不同为1

      public static void main(String[] args) {
        /*
          计算机存储、操作的是补码
         */
        int a = 15;
        int b = 127;

        /*
          15  原码：0000 1111 反码：0000 1111 补码：0000 1111
          127 原码：0111 1111 反码：0111 1111 补码：0111 1111
          a&b 0000 1111
          a|b 0111 1111
          ~a 值为-16 计算机存储为：补码 1111 1111 1111 1111 1111 1111 1111 0000
                                反码 1111 1111 1111 1111 1111 1111 1110 1111 即补码减去1
                                原码 1000 0000 0000 0000 0000 0000 0001 0000 即-16
          a^b 0111 0000
          注意：正数左右位移都补0
          a>>1 0000 0111
          a<<1 0001 1110
         */
        System.out.println(a >> 1);
        System.out.println(a << 1);
        int c = -15;
        int d = -127;
        /*
           -15 原码：1000 0000 0000 0000 0000 0000 0000 1111
               反码：1111 1111 1111 1111 1111 1111 1111 0000
               补码：1111 1111 1111 1111 1111 1111 1111 0001 即反码加上1
          -127 原码：1000 0000 0000 0000 0000 0000 0111 1111
               反码：1111 1111 1111 1111 1111 1111 1000 0000
               补码：1111 1111 1111 1111 1111 1111 1000 0001
           c&d 1111 1111 1111 1111 1111 1111 1000 0001
           c|d 1111 1111 1111 1111 1111 1111 1111 0001
           ~c  0000 0000 0000 0000 0000 0000 0000 1110
           c^d 0000 0000 0000 0000 0000 0000 0111 0000
          注意：负数向右位移补1，向左位移补0
          c>>2 补码：1111 1111 1111 1111 1111 1111 1111 1100
               反码：1111 1111 1111 1111 1111 1111 1111 1011
               原码：1000 0000 0000 0000 0000 0000 0000 0100
          c<<2 补码：1111 1111 1111 1111 1111 1111 1100 0100
               反码：1111 1111 1111 1111 1111 1111 1100 0011
               原码：1000 0000 0000 0000 0000 0000 0011 1100
         */
        System.out.println(c >> 2);
        System.out.println(c << 2);
    }

6.标识符和关键字

标识符规则：（1）标识符由字母、下划线、$和数字组成；

（2）标识符的第一个字符不能是数字；

（3）标识符不能使用关键字和保留字；

（4）标识符不能是true、false和null；

（5）标识符区分大小写，长度不受限制

关键字：abstract、assert、boolean、break、byte、case、catch、char、calss、const、continue、default、do、

double、else、enum、extends、final、finally、float、for、goto、if、implements、import、instanceof、

int、interface、long、native、new、package、private、protected、public、return、short、static、strictfp、

super、switch、synchronized、this、thow、throws、transient、try、void、volatile、while

7.数据类型

基本数据类型：byte（1个字节）、short（2个字节）、int（4个字节）、long（8个字节）、boolean（true和false）、

char（2个字节）、float（4个字节）、double（8个字节）

引用数据类型：数组、类和接口

8.==运算符

（1）如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）

（2）如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

9.switch(表达式)

表达式的值必须是下述几种类型之一：byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0)

        public enum Season {
           春季, 夏季, 秋季, 冬季;
        }       

        Season season = Season.春季;
        switch (season) {
            case 冬季:
                System.out.println("隆冬腊月");
                break;
            case 夏季:
                System.out.println("暑假真好");
                break;
            case 春季:
                System.out.println("春天种下种子");
                break;
            case 秋季:
                System.out.println("秋天收获果实");
                break;
            default:
                break;
        }

10.进制转换

        //十进制转十六、八、二进制
        String var1 = Integer.toHexString(110);
        String var2 = Integer.toOctalString(110);
        String var3 = Integer.toBinaryString(110);
        System.out.println(var1);
        System.out.println(var2);
        System.out.println(var3);
        //十六、八、二进制转十进制
        Integer var4 = Integer.parseInt("6e", 16);
        Integer var5 = Integer.parseInt("156", 8);
        Integer var6 = Integer.parseInt("1101110", 2);
        System.out.println(var4);
        System.out.println(var5);
        System.out.println(var6);

11.Scanner获取键盘输入

        //输入不匹配异常InputMismatchException
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int num = scanner.nextInt();
            System.out.println(num);
        }

12.类

类的组成：属性（成员变量）、方法、构造器、代码块、内部类

成员变量：（1）加载到堆空间中（非static）；

（2）有默认初始化值；

（3）定义在类的一对{}内；

（4）可以在声明属性时，指明其权限，使用权限修饰符

局部变量：（1）加载到栈空间；

（2）没有默认初始化值，调用前显式赋值；

（3）定义在方法内、代码块内、构造器内，方法形参、构造器形参；

（4）不可以使用权限修饰符

13.面向对象三大特征

（1）封装性：隐藏对象的属性和实现细节

（2）继承性：子类拥有父类的数据属性和行为，并可以扩展新功能

（3）多态性：父类的引用指向子类的对象

14.方法重载

重载方法参数必须不同，与返回值无关

（1）参数个数不同，如method(int x)与method(int x,int y)不同

（2）参数类型不同，如method(int x)与method(double x)不同g

（3）参数顺序不同，如method(int x,double y)与method(double x,int y)不同

15.方法重写

（1）方法的重写是指两个方法的返回值、方法名、参数的类型和个数相同(子类重写父类的方法)

（2）如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类

public class MethodOverride {
    public static void main(String[] args) {
        /*
          运行结果：
             讲话
             吃饭
             我是学生，会讲话
             我是学生，会走路
             吃饭
             我是学生，会讲话
             吃饭
             我是学生，会走路
         */
        //父类的引用指向父类的对象
        Person person = new Person();
        person.speak();
        person.eat();
        //子类的引用指向子类的对象
        Student student = new Student();
        student.speak();
        student.walk();
        student.eat();

        //父类的引用指向子类的对象
        Person var = new Student();
        //调用的是子类重写的方法
        var.speak();
        var.eat();
        if (var instanceof Student) {
            Student stu = (Student) var;
            //子类特有的方法需要向下转型
            stu.walk();
        }
    }
}

class Person {
    public void speak() {
        System.out.println("讲话");
    }

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

class Student extends Person {
    @Override
    public void speak() {
        System.out.println("我是学生，会讲话");
    }

    @Override
    public void eat() {
        super.eat();
    }

    public void walk() {
        System.out.println("我是学生，会走路");
    }
}

16.this关键字

（1）在本类的成员方法中，访问本类的成员变量

（2）在本类的成员方法中，访问本类的另一个成员方法

（3）在本类的构造方法中，访问本类的另一个构造方法

public class Student {
    private String stuName;
    private String stuAge;

    public Student(String stuName) {
        System.out.println("构造方法一");
        this.stuName = stuName;
    }

    public Student(String stuName, String stuAge) {
        this(stuName);
        this.stuAge = stuAge;
        System.out.println("构造方法二");
        this.study();
    }

    public void study() {
        System.out.println("我是学生，只会学习");
    }

    public static void main(String[] args) {
        /*
          运行结果：
             构造方法一
             构造方法二
             我是学生，只会学习
         */
        Student student = new Student("小明", "23");
    }
}

17.super关键字

（1）在子类的成员方法中，访问父类的成员变量

（2）在子类的成员方法中，访问父类的成员方法

（3）在子类的构造方法中，访问父类的构造方法

public class Person {
    String name = "我是人类";

    public Person(String name) {
        this.name = name;
        System.out.println("父类的有参构造方法");
    }

    public void walk() {
        System.out.println("能走路");
    }
}


public class Student extends Person {
    String name = "我是学生";

    public Student(String name) {
        super(name);
    }

    public void study() {
        System.out.println(super.name);
        super.walk();
    }

    public static void main(String[] args) {
        /*
          运行结果：
             父类的有参构造方法
             测试一下
             能走路
         */
        Student student = new Student("测试一下");
        student.study();
    }
}

18.static关键字

（1）static修饰的方法，叫静态方法。通过类名.方法名调用

（2）static修饰的变量，叫静态变量。static是不允许用来修饰局部变量，静态变量属于类，通过类名.变量名调用

（3）static修饰的类，叫静态内部类。static是不允许用来修饰普通外部类

（4）static修饰的代码块，叫静态代码块。jvm初始化类的时候执行

19.final关键字

（1）final修饰的类，不能被继承

（2）final修饰的方法，不能被重写

（3）final修饰成员变量，必须在定义时、代码块或者构造器中进行初始化赋值

20.instanceof运算符

判断一个对象是否属于一个类

        Object var = "字符串";
        //判断"字符串"是否是String类的对象
        if (var instanceof String) {
            String obj = (String) var;
            System.out.println("Object是所有类的父类");
        }

21.包装类

（1）byte Byte

（2）short Short

（3）int Integer

（4）long Long

（5）float Float

（6）double Double

（7）boolean Boolean

（8）char Character

22.构造器

（1）如果没有定义构造器，则会默认一个无参构造器

（2）如果自定义了构造器，则会覆盖默认构造器（一般都会声明空参构造器）

（3）构造器之间属于重载

public class Person {
    private String personName;
    private String personAge;

    public Person() {
    }

    public Person(String personName) {
        this.personName = personName;
    }

    public Person(String personName, String personAge) {
        this.personName = personName;
        this.personAge = personAge;
    }

    public String getPersonName() {
        return personName;
    }

    public void setPersonName(String personName) {
        this.personName = personName;
    }

    public String getPersonAge() {
        return personAge;
    }

    public void setPersonAge(String personAge) {
        this.personAge = personAge;
    }
}

23.抽象类和接口

（1）抽象类不能实例化，但可以有构造器、属性、普通方法、抽象方法

（2）有抽象方法的类一定是抽象类

（3）子类只有重写了父类中的抽象方法后，方可实例化

（4）接口与接口之间可以继承，而且可以多继承

（5）类可以实现多个接口

（6）接口中不能定义构造器，不能实例化

（7）JDK7及以前只能定义全局常量和抽象方法，JDK8除定义全局常量和抽象方法外，增加静态方法、默认方法

public class Professor extends Man {
    public Professor(String name) {
        super(name);
    }

    @Override
    public void speak() {
        System.out.println("会讲话");
    }

    @Override
    public void eat() {
        System.out.println("会吃饭");
    }

    @Override
    public void teach() {
        System.out.println("会教书");
    }

    @Override
    public void gender() {
        System.out.println("是男人");
    }

    public static void main(String[] args) {
        /*
          运行结果：
             是男人
             会讲话
             会吃饭
             会花钱
             会教书
             老师
             静态方法
             默认方法
         */
        Professor professor = new Professor("李斯");
        professor.gender();
        professor.speak();
        professor.eat();
        professor.spendMoney();
        professor.teach();
        System.out.println(Teacher.PROFESSION);
        Teacher.staticMethod();
        professor.defaultMethod();
    }
}

/*
  抽象类
 */
abstract class Man implements Person {
    protected String name;

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

    public abstract void gender();

    protected void spendMoney() {
        System.out.println("会花钱");
    }
}

interface Teacher {
    /*
     * 静态常量
     */
    String PROFESSION = "老师";

    void teach();

    /*
      默认方法
     */
    default void defaultMethod() {
        System.out.println("默认方法");
    }

    /*
      静态方法
     */
    static void staticMethod() {
        System.out.println("静态方法");
    }
}

interface Person extends Animal, Teacher {
    void speak();
}

interface Animal {
    void eat();
}

24.匿名对象和匿名类

public class Student implements Person {
    private Person person;

    public Student(Person person) {
        this.person = person;
    }

    @Override
    public void walk() {
        person.walk();
    }

    public static void main(String[] args) {
        /*
          运行结果：
             我是匿名类
             我是匿名对象
         */
        Student student = new Student(new Person() {
            @Override
            public void walk() {
                System.out.println("我是匿名类");
            }
        });
        student.walk();

        Student student1 = new Student(new Man());
        student1.walk();
    }
}

interface Person {
    void walk();
}

class Man implements Person {

    @Override
    public void walk() {
        System.out.println("我是匿名对象");
    }
}

25.值传递机制

形参：方法定义时，声明的小括号内的参数

实参：方法调用时，实际传递给形参的数据

（1）如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值

（2）如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值

26.可变个数形参

（1）可变个数形参的格式：数据类型 ... 变量名

（2）当调用可变个数形参的方法时，传入的参数个数可以是n个

（3）可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载

（4）可变个数形参在方法的形参中，必须声明在末尾

（5）可变个数形参在方法的形参中,最多只能声明一个可变形参

public class VariableArgs {
    public static void main(String[] args) {
        /*
           运行结果：
              AA
              BB
              CC
         */
        String[] strArr = {"AA", "BB", "CC"};
        showArgs(strArr);
    }

    public static void showArgs(String... args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

27.Object类

（1）Object类是所有Java类的根父类

（2）如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

（3）常用方法toString()、equals(Object obj)、getClass()

28.代码块

public class CodeBlock {
    /*
      （1）静态代码块
          随着类的加载而执行,而且只执行一次
          如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
          静态代码块的执行要优先于非静态代码块的执行
          静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
      （2）非静态代码块
          随着对象的创建而执行
          每创建一个对象，就执行一次非静态代码块
          如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
          非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
     */
    private String name;
    private static String desc = "静态变量";

    public CodeBlock() {
        System.out.println("空参构造方法");
    }

    public CodeBlock(String name) {
        this.name = name;
        System.out.println("有参构造方法");
    }

    {
        System.out.println("普通代码快");
        System.out.println(desc);
    }

    static {
        System.out.println("静态代码块");
        System.out.println(desc);
        info();
    }

    public static void info() {
        System.out.println("静态方法");
    }

    public static void main(String[] args) {
        /*
          运行结果：
             静态代码块
             静态变量
             静态方法
             普通代码快
             静态变量
             有参构造方法
             ================
             普通代码快
             静态变量
             有参构造方法
         */
        CodeBlock codeBlock1 = new CodeBlock("测试代码块1");
        System.out.println("================");
        CodeBlock codeBlock2 = new CodeBlock("测试代码块2");
    }
}

29.四种权限修饰符

public protected (default) private

同一个类 yes yes yes yes

同一个包 yes yes yes no

不同包子类 yes yes no no

不同包非子类 yes no no no

30.Arrays工具类

     public static void main(String[] args) {
        int[] arr1 = {5, 2, 6, 1, 9, 3};

        /**
         * void sort(int[] a) 按照数字顺序排列指定的数组
         * String toString(short[] a) 返回指定数组的内容的字符串表示形式
         */
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));

        /**
         * boolean equals(int[] a,int[] b):判断两个数组是否相等
         */
        int[] arr2 = {5, 2, 6, 1, 9, 3};
        int[] arr3 = {5, 2, 6, 1, 9, 3};
        boolean isEquals = Arrays.equals(arr2, arr3);
        System.out.println(isEquals);

        /**
         * <T> List<T> asList(T... a)返回由指定数组支持的固定大小的列表
         */
        List<int[]> list = Arrays.asList(arr3);
        for (int[] arr : list) {
            for (int a : arr) {
                System.out.println(a);
            }
        }

        /**
         * int binarySearch(int[] a,int key) 二分法查找（使用前数组需要排序）
         */
        int[] arr4 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int index = Arrays.binarySearch(arr4, 210);
        if (index >= 0) {
            System.out.println(index);
        } else {
            System.out.println("未找到");
        }
    }

31.子类实例化过程

public class CreateSubclass {
    public static void main(String[] args) {
        /*
          由父及子，静态先行
          运行结果：
             Mid的静态初始化块
             Leaf的静态初始化块
             Mid的普通初始化块
             Mid的无参数的构造器
             Mid的带参数构造器，其参数值：尚硅谷
             Leaf的普通初始化块
             Leaf的构造器

             Mid的普通初始化块
             Mid的无参数的构造器
             Mid的带参数构造器，其参数值：尚硅谷
             Leaf的普通初始化块
             Leaf的构造器
        */
        new Leaf();
        System.out.println();
        new Leaf();
    }
}

class Mid {
    static {
        System.out.println("Mid的静态初始化块");
    }

    {
        System.out.println("Mid的普通初始化块");
    }

    public Mid() {
        super();
        System.out.println("Mid的无参数的构造器");
    }

    public Mid(String msg) {
        //通过this调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数构造器，其参数值："
                + msg);
    }
}

class Leaf extends Mid {
    static {
        System.out.println("Leaf的静态初始化块");
    }

    {
        System.out.println("Leaf的普通初始化块");
    }

    public Leaf() {
        //通过super调用父类中有一个字符串参数的构造器
        super("调用父类");
        System.out.println("Leaf的构造器");
    }
}

32.内部类

（1）成员内部类 1.可以有权限修饰符；2.不能定义static静态资源；3.可以直接访问外部类静态和非静态资源；4.可以继承类和实现接口；5.实例化依赖外部类的实例；6.资源不能被外部类直接访问

（2）静态内部类 1.可以有权限修饰符； 2.可以定义static静态资源和非静态资源；3.可以直接访问外部类静态资源，但不能访问非静态资源；4.可以继承类和实现接口；5.实例化不需要依赖外部类的实例； 6.资源不能被外部类直接访问

（3）局部内部类 1.不可以有权限修饰符，且不能声明为static ；2.声明在方法体内，只在方法体内有效； 3.可以在方法体内实例化；4.不能定义static静态资源；5.可以继承类和实现接口； 6.在静态方法内声明，只能访问外部类静态资源；7.在普通方法内声明，可以问外部类静态资源和非静态资源；8.访问方法内的局部变量必须是final常量