Java基础中的基础知识汇总一

﹏ヽ暗。殇╰゛Y 2023-09-23 21:34 144阅读 0赞

### 文章目录 ###

*  常见面试题：共7题
 *  语言基础知识点
 *  面向对象知识点

# 常见面试题：共7题 #

1.  java的八种基本数据类型是什么?
    
     *  byte:字节型，用于存储整数的，占用1个字节，范围-128到127
     *  short:短整型，用于存储整数的，占用2个字节，范围-32768到32767
     *  int:整型，用于存储整数的，占用4个字节，范围-231到231-1
     *  long:长整型，用于存储整数的，占用8个字节，范围-263到263-1
     *  float:单精度浮点型，用于存储小数的，占用4个字节，不能表示精确的值
     *  double:双精度浮点型，用于存储小数的，占用8个字节，不用表示精确的值
     *  boolean:布尔型，用于存储true或false的，占用1个字节
     *  char:字符型，采用Unicode字符编码格式，用于存储单个字符，占用2个字节
2.  switch能作用在哪些类型的变量上?
    
     *  可以作用于:byte,short,int,char,String,枚举类型，其它类型都是不允许的
3.  重写与重载的区别:
    
     *  重写:发生在父子类中，方法名相同，参数列表相同
        
        > 当派生类觉得超类的行为不好时，可以通过重写来修改超类中的方法
     *  重载：发生在同一类中，方法名相同，参数列表不同
        
        > 是完全不同的方法，只是正好方法名相同而已
4.  实例变量与静态变量的区别:
    
     *  实例变量：属于对象的，在创建对象时存储在堆中，创建了多少个对象，则实例变量就会在堆中存储几份，需要通过引用打点来访问
     *  静态变量：属于类的，在类被加载时存储在方法区中，无论创建了多少个对象，静态变量在内存中都只有一份，常常通过类名打点来访问
5.  问：java是值传递还是引用传递?
    
     *  java中无论是基本类型还是引用类型，都是值传递
        
         *  对于基本类型而言，传递的是具体的值的副本
         *  对于引用类型而言，传递的是具体的地址的副本
            
            > 注意:网站上说java有引用传递的文章都是错误的~!
6.  String str = new String(“abc”); 创建了几个字符串对象？
    
    答：2个。一个是"abc"字面量对象并缓存在了字符串常量池中。另一个是new出来的String对象。
7.  ==和equals()的区别：
    
     *  ==：若为基本类型则比较的是具体的值是否相同，若为引用类型则比较的是引用的地址是否相同。
        
            int a=5,b=5;
            System.out.println(a==b); //比较a与b的值是否相同
            Student zs = new Student();
            Student ls = new Student();
            System.out.println(zs==ls); //比较zs与ls的地址是否相同
     *  equals()：基本类型是不能使用equals()来判断相等的，只有引用类型才能使用equals() 来判断相等。equals()是在Object类中定义的，内部比较的还是引用的地址是否相同，但是比较地址没有参考意义，所以常常需要去重写equals()来比较对象的属性(数据)是否相同。Java的String类中已经重写了equals()来比较字符串内容是否相同。
        
            String s1 = new String("hello"); 
            String s2 = new String("hello");
            System.out.println(s1.equals(s2)); //true，equals()比较字符串内容是否相同

# 语言基础知识点 #

1.  标识符的命名规则：
2.  八种基本数据类型有哪些？每种类型所占的字节数？
    
     *  整数直接量默认为int类型、浮点数直接量默认为double类型
3.  字符串连接符运算符：+
    
        System.out.println(5+10+"你"); //15你
        System.out.println(5+"你"+10); //5你10
4.  算术运算符: +、-、\*、/、%、++、–
    
        int a = 5;
        int b = ++a;
        System.out.println(a); //6
        System.out.println(b); //6
5.  逻辑运算符：
    
     *  &&：短路与(并且)----见false则false
     *  ||：短路或(或者)-----见true则true
     *  !：逻辑非(取反)--------非真则假，非假则真
        
        > 逻辑运算符和关系运算的结果为boolean型
6.  分支结构：switch…case
    
     *  看到break会停，看不到就往下一直串，一直串到底
     *  default可以写在switch里的任何地方，但无论写在哪儿，都一定是先匹配case，当所有case都未匹配时才执行
        
            int num = 6;
            switch(num){
                    
                default: //所有case都未匹配时才执行
                   ....  //此处若没有break，依然会继续穿到下面的代码去
                case 1:
                   ....
                case 2:
                    ....
            }
7.  三种循环结构的执行规则：带数
    
     *  while：先判断后执行，有可能一次都不执行
     *  do…while：先执行后判断，至少执行一次
8.  第一阶段共三种异常:
    
     *  ArrayIndexOutOfBoundsException：数组下标越界异常
        
         *  数组下标从0开始，最大到(数组的长度-1)，超出范围时会发生下标越界异常
     *  NullPointerException：空指针异常
        
         *  用null值做操作时会发生空指针异常
     *  ClassCastException：类型转换异常
        
         *  强制类型转换时若不符合那两个成功的条件时会发生类型转换异常
9.  数组下标从0开始，最大到(数组的长度-1)  
    数组的长度是length属性、字符串的长度是length方法
10. 关键字：
    
     *  break：可以用在switch和循环中，用在switch中用于跳出switch，用在循环中用于跳出循环
     *  continue：只能用在循环中，跳过循环体中剩余语句而进入下一次循环
     *  void：方法无返回值
     *  return：结束方法
        
         *  return 值; //1)结束方法 2)返回结果给调用方-----用在有返回值的方法中
         *  return; //1)结束方法--------------用在无返回值的方法中

# 面向对象知识点 #

1.  实例成员是由**引用名**打点来访问的，静态成员是由**类名**打点来访问的  
    静态方法中**只能**直接访问静态成员，实例方法中可以直接访问实例的也可以直接访问静态
    
    静态变量常常也称为**类变量**\---------属于类的叫类变量(也叫做静态变量)
2.  访问权限从低到高依次为: private，默认的(default)，protected，public
    
    > 类/接口的访问权限只能是public或默认的，类中成员的访问权限如上4种都可以
3.  向上造型：前面是超类型/接口，后面是派生类型
    
        //假设Aoo是超类，Boo是派生类
        Aoo o1 = new Aoo(); //没造
        Boo o2 = new Boo(); //没造
        Aoo o3 = new Boo(); //向上造型
        o1 = o2; //向上造型
4.  final的变量不能被改变、final的方法不能被重写、final的类不能被继承
5.  程序的执行过程(若有的话):
    
     *  超类的static块
     *  派生类的static块
     *  超类的构造方法
     *  派生类的构造方法
    
        //如果一个类中出现多个静态块，则会由上到下执行----如下代码先执行静态块1，再执行静态块2
        class Aoo{
              
            static{
              
                System.out.println("静态块1");
            }
            static{
              
                System.out.println("静态块2");
            }
        }
6.  重写方法被调用时，一定是看对象的类型
    
     *  重写：方法名和参数列表必须与超类完全相同
        
         *  派生类方法的访问权限大于或等于超类的
         *  派生类方法的返回值类型小于或等于超类的
         *  派生类方法抛出的异常小于或等于超类的
     *  重载：方法名相同，参数列表不同(参数个数不同、参数类型不同)
7.  构造方法(constructor)：构造器、构建器、构造函数
    
     *  作用：给实例变量赋初始值
     *  若自己不写则默认有一个无参构造，若自己写了则不再默认提供
     *  构造方法也属于类中成员，可以用4种访问修饰符来修饰
        
            class Aoo{
                    
                private Aoo(){
                     //构造方法也可以私有，若构造私有了，则别类的中不能new Aoo对象了
                }
            }
8.  类是由class来定义的，接口是由interface来定义的，抽象类是由abstract修饰的
9.  包含抽象方法的类必须是抽象类/接口，派生类继承后必须重写所有抽象方法
    
    重写接口中的方法时，必须加public权限
10. 代码顺序:
    
     *  先package
     *  而后import
     *  然后class
11. == 对于基本类型而言，是判断值是否相同， ==对于引用类型而言，是判断引用的地址是否相同
    
    String中重写了Object的equals()来判断字符串内容是否相同
12. String字符串一旦定义好，对象内容不能再改变了，但是引用可以重新赋值(指向新的对象)，字符串字面量会存储在字符串常量池中，当下次内容相同的字符串被使用，将直接从常量池中获取
    
        String s1 = "123abc";
        String s2 = new String("123abc");
        String s3 = "123"+"abc"; //编译器直接运算好并保存，相当于String s3 = "123abc"
        String s4 = s1;
        System.out.println(s1==s2); //false
        System.out.println(s1==s3); //true
        System.out.println(s1==s4); //true
        System.out.println(s2==s4); //false
        System.out.println(s2.equals(s4)); //true
        一定要看StringDemo里面的那些代码、要看常量池图、面试题图
13. Integer类：是一个引用类型(包装类)，也能装整数

```java
    Integer i = 5; //自动装箱了，自动补全代码Integer i = Integer.valueOf(5);
    int j = i; //自动拆箱了，自动补全代码int j = i.intValue();
    ```