Java中常见细节性知识点精心整理

整数小数之间的转换

        int i=10;
        String s="100";
        int i1 = Integer.parseInt(s);//核心
        String s1 = String.valueOf(i);//核心

生成随机数

import java.util.Random;
Random random=new Random();
int number=random.nextInt(x);
//number 的范围是 [0,x)整数

• 格式化:Ctrl Alt l

多个数组指向相同

空指针异常

int[] arr=new int[3];
arr=null;
System.out.print(arr[0]);
//NullPointerException

方法不能嵌套定义

判断方法重载的条件

• 主要看 函数名 和 函数的形参
• *但是，假如两个方法函数名和函数形参都符合，但是不在同一个类中，也不构成方法重载

对于引用类型的参数，形式参数的改变，影响实际参数的值

例题:不死神兔

            //不死神兔:有一对兔子，从出生后第三个月起每个月生一对兔子，小兔子长到第三个月后每个月也会生一对兔子假设兔子都不会死,求第20个月后，兔子的对数是多少
   // 1 1 2 3 5 ......从三个数起，每个数为前两个数之和
public class  MainApplication {
        public static void main(String[] args) {
            int[] arr=new int[20];
            arr[0]=1;
            arr[1]=1;
            for (int i = 2; i < arr.length; i++) {
                arr[i]=arr[i-2]+arr[i-1];
            }
            System.out.println("第19天的总兔子对数为"+arr[19]);
        }
    }

String 类在java.lang包下，使用的时候不需要导包

• 字符串效果上相当于字符数组(char[]),但是底层原理是字节数组(byte[])

•     //字符串的构造方法
      char[] abs={'a','b','c'};//字符数组
      byte[] byt={97,98,99};//字节数组
      String s2="abc";//直接复制
      
      String str1 = new String(abs);
      String str2 = new String(abs);
  //在运行上述代码时,JVM先会创建一个字符数组，然后每次new的时候都会有一个新的地址
  //虽然str1和str2的内容相同，但是它们的地址值不相同
  

= = 的比较 Vs equals()

• 若是基本数据类型,比较的是数据值是否相同

• 若是引用数据类型，比较的是地址值是否相同

• str1.equals(str2) 比较的是str1和strt2的值是否相同

String StringBuilder 相互转换

//String ->  StringBuilder
//直接使用StringBuilder的构造方法
String s1="hello";
StringBuilder s2=new StringBuilder(s1);

//StringBuilder -> String
//使用StringBuilder类中一个toString方法
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("hello");
String s=stringBuilder.toString();

父类也被称为 基类或超类

继承

• 一个类如果没有父类，都默认继承Object类

继承的好处和弊端

• 好处
  1. 提高了代码的复用性(多个类的成员可以放到一个类中)
  2. 提高了代码的维护性(若代码需要修改，修改一处即可)
• 弊端
  • 类的耦合性增强，当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性

继承中变量的访问特点

• 子类局部范围找
• 子类成员范围找
• 父类成员范围找(第一个父亲没有，继续找第二个父亲，知道最后一个父亲还没有的话就会报错)

//父类
public class Fu {
    int age=40;
}
//子类_1
public class Zi_1 extends Fu {

    int height=175;
    public void showZi(){
        System.out.println(age+","+height);
    }
}
//子类_2
public class Zi_2 extends Fu {

    int height=175;
    int age=20;
    public void showZi(){
        System.out.println(age+","+height);
    }
}
//子类_3
public class Zi_3 extends Fu {

    int height=175;
    int age=20;
    public void showZi(){
        int age=10;
        System.out.println(age+","+height);
    }
}
//调用
public class Test {
    public static void main(String[] args) {
        //测试1
        Zi zi_1 = new Zi_1();
        zi_1.showZi();//此时,结果为 40  175
        //测试2
        Zi zi_2 = new Zi_2();
        zi_2.showZi();//此时,结果为 20  175
        //测试3
        Zi zi_3 = new Zi_3();
        zi_3.showZi();//此时,结果为 10  175
    }
}
//结论：使用一个变量的时候，程序首先会在方法内部去找，如果该方法内部不存在该变量，那么就回去本类的成员变量里面去找，如果还没有，就会去父类成员变量里面去找。

• this&&super

public class Fu {
    int age=40;
}
//子类
public class Zi_3 extends Fu {
    int age=20;
    public void showZi(){
        int age=10;
        System.out.println(age);//10
        System.out.println(this.age);//20   this代表 本类 中成员变量的引用
        System.out.println(super.age);//40   super 父类对象的引用
    }
}

继承中构造方法的访问特点

• 子类中所有类型的构造方法(有参构造and无参构造)都会 默认的访问父类的无参构造方法

  • 原因
    1. 子类会继承父类中的数据，可能还会使用父类中的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
    2. 每一个子类构造方法的默认第一条语句都是: super()

• 如果父类中没有无参构造方法？

    public class Fu {
        int age=10; 
        public Fu(int age){
           
        }
    }
  

  1. 用super显示的调用父类中有参构造方法 super(20);
  2. 在父类中自己亲自提供一个无参构造方法

方法的重写

• 子类中出现了和父类一模一样的方法声明

• 如果父类中的方法被final状态修饰符修饰，则子类不可以重写父类中这个被final修饰的方法,子类虽然不可以重写父类中被final修饰符修饰的方法，但是在实例化子类对象后还是可以调用父类中这个被final修饰符修饰的方法的

  //父类
  public class Fu {
  
      public final void call(String name){
          System.out.println("给"+name+"打电话");
      }
  }
  //子类
  public class Zi extends Fu {
      @Override
      public void call(String name){//无法重写，即使加上final也不行
          System.out.println("视频电话");
          super.call(name);
      }
  }
  

• @Overrid

  1. 是一个注解
  2. 可以帮助我们检查重写方法的正确性

• 父类中私有内容(private void call(){})子类不可能重写

• 子类方法的访问权限不能比父类低(public>默认>私有)