欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

【Java】基础知识笔记

程序员文章站 2024-01-30 15:55:58
...

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常量

相关标签: Java基础