2021-07 面试复习之 Java细节（一）

Java 回顾基础细节

---

变量 常量

• 变量的作用域：
  类变量 static，和类同生存消失
  实例变量 从属于对象，如果不初始化则默认为 0 0.0 false或者Null
  局部变量 必须声明和初始化值

  public class Variable{
  	static int all = 0;//类变量
  	String str = "Hello World";//实例变量
  	public void method(){
  		int i =0; //局部变量
  	}
  }
  

• 命名规范
  类名，变量，方法：见名知意
  类成员变量：首字母小写驼峰
  局部变量：首字母小写驼峰
  常量：大写字母和下划线 MAX_VALUE
  类名：首字母大写和驼峰原则 Man GoodMan
  方法名： 首字母小写和驼峰 run() runFast()

• 常量const 初始化后不可改变 用final定义

  static final double PI =3.14;
  

数据类型

强变量的使用严格规定，所有变量必须先定义后才可以使用。

• 基本数据类型：整数，浮点，char类型

1. 整数
   最常用int 4个字节；
   byte 1个字节：-128~127
   short 2个字节：-32768~32767
   long 8个字节： long a = 80L;后面要加L
2. 浮点数
   float 4个字节： float num = 50.1F 后面要加F
   double 8个字节：比较常用
3. char类型 字符
   char 2个字节：char name = " A"只可以单个字符
   注意：String是类，不是数据类型
4. boolean
   只是占一位：false和true

• 引用数据类型：类，接口，数组

字节（byte） 计算机数据处理的基本单位，习惯用大写B表示；
位（bit）计算机内部存储的最小单位，11001100是一个8位二进制数；
1B = 8bit ；
字符 计算机中使用的字母数字和符号

• 整数扩展：

int i = 10 ; 
int j = 010;  // 八进制
int k = 0x11; // 十六进制

• 浮点扩展：
  float是有限 离散 舍入误差 大约 接近且不等于
  不可以用float进行比较，一般使用数学工具类----BigDecimal

float i = 10 ; 
double d = 1.0/10; //i和d不相等

• 字符拓展：
  所有的字符本质都是数字 0~65536 都过Unicode编码
  U0000 ~ UFFFF 里面表示的是字符
  比如：\u0061 是97代表的小a

char c1 = 'a';  //输出是(int)强制转换是97
char c2 = '中';	//输出是(int)强制转换是20013
char c3 = '\u0061';  //输出是a

• 转义字符：
  \t 制表符
  \n换行

• 底层：
  new出来的在堆内存中，不new出来的在常量池中。

String a = new String("hello world");
String b = new String("hello world");
String c = "hello world";
String d = "hello world";
//a 不等于 b ； c等于d。因为ab比较的是内存地址（引用），cd是字符串常量池

命令行传参

javac 编译成class文件
java 执行.class文件

在具有包的环境中 package com.zhang.method

使用javac hello.java打包后生成的.class文件 并不可以在当前文件夹进行加载java hello会报错： “ 找不到或无法加载主类”
只有在src 的目录下进行java hello才可以成功运行

不定项参数

1. JDK1.5 java支持传递同类型的可变参数给一个方法
2. 在方法声明中，在指定参数类型后加省略号…
3. 一个方法中只指定一个可变参数，必须是方法的最后一个参数。任何普通参数必须在它之前声明。

public void test(int... i) {
	System.out.println(i)
}

递归

自己调用自己：（递归结构包括2部分）
递归头：
递归体：

Scanner对象

IO 一定要记得关闭
next()：一定读取到有效字符才可以结束输入；对输入有效字符之前遇到的空白，next()方法会去除掉；有效字符后的空白是分隔符或结束符；next()不可以得到有空格的字符串。
nextline()：返回的是输入回车和之前的所有字符。
sacneer.nextInt sacneer.nextFloat

public static void main(String[] args ){
	Scanner scanner  = new Scanner(System.in);
	System.out.println("使用nextLine方式接收：");
	if (scanner.hasNextLine()){
		String str = scanner.nextLine();
		System.out.println("输入的内容为：" + str);
	}
	scanner.close();
}

基本类

math类： 幂运算 2^3 Math.pow(2,3)

JDK

JDK5特性：java.util.Scanner
JDK7特性：使用下划线_不影响读数。int a = 10_0000_0000;

运算符

1. 常用的是 算数运算符（加减乘除取余），赋值运算符（=）和关系运算符（大于小于等于）
2. 逻辑运算符 && || ！ 注意短路运算，当&&前面为false时，后面的内容不执行
3. 位运算符 & | ^ ~ 与 或 异或 非 >> << 右移 左移

  // 2*8 怎么计算比较快 ——效率及其高
  2<<3 //将2左移3位， 2 * 2 * 2 * 2 

4. 条件运算符 ？=

包

• 包的本质就是文件夹；
• 一般就是公司域名倒置 显示包名 package com.baidu.www
• 导入包 import package XXX
• JavaDoc
  javadoc -encoding UTF-8 -charset UTF-8 Doc.java

流程控制

• 判断字符串用 equals方法
• case 如果没有break，会有穿透现象，会继续执行。
• 变量类型支持 byte short int char。在JDK7之后还可以是 String类型

switch(express){
   case value:
   	break;
}

• do while 和 while 不同之处是在于，do while 至少会执行一次。
• for死循环代码 for( ; ; )
• 乘法表

public class Multplication {
    public static void main(String[] args) {
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print( j +"*" + i +"=" +(i*j)  +"\t");
            }
            System.out.println();
        }
    }
}

• JDK 5 引入了用于数组或者集合的增强型for循环 for(声明语句:表达式)

//打印三角形
public class Rectangle {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j > i; j--) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2*i-1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }/*
    *
   ***
  *****
 *******
*********
*/

数组

• 数组默认： 0 0.0 false或者Null
• 静态初始化 int[] a ={1,2,3};
• 动态初始化 int[] a = new int[];
• 特点：
  1. 长度确定的，数组一旦被创建，大小不可以改变的
  2. 元素相同类型，可以是引用类型或者基本类型
  3. 数组本身就是对象，java对象是在堆中的数组对象本身就在堆中
• Arrays类 util包里面
• 冒泡排序

// O(n方) 冒泡排序
public static void sort(int[] array){
	//临时变量
	int temp = 0;
	for(int i = 0; i< array.lenth-1;i++){
		for(int j = 0; j<array.length-1-i;j++){
			if(array[j+1]<array[j]){
				temp = array[j];
				array[j]=array[j+1];
				array[j+1]=temp;
			}
		}
	}
}

面向对象

• 面向对象编程的本质是：以类的方式组织代码，以对象的方式组织（封装）数据。
• 特性：封装，继承，多态
• 方法

方法的定义：
修饰符  返回值类型  方法名(...){
	方法体
	return 返回值；
}
public void do(){
	return;
}
public int maxString(int a,int b){
	return a >b ? a:b;
}

1. return就表示 结束方法，返回一个结果
2. 静态方法（static）：类名.方法
3. 非静态方法：实例化这个类 ，new对象
4. static是和类一起加载的，非static是和对象一起加载的。
5. 构造方法（构造器）①必须和类名相同，②没有返回值（也不能有void）——作用：①可以实例化初始值②new本质是调用构造器——注意：定义有参构造后如想使用无参构造，必须显示定义一个午餐后遭
6. 实例化初始值：①使用new关键字，本质就是在调用构造器；②有参构造：一单定义了有参构造，无参必须显示定义。

引用一张图
封装： 高内聚 低耦合； 属性私有-使用get/set方法

1. 提高安全性 保护数据
2. 隐藏代码实现细节
3. 统一接口
4. 系统可维护性

Object 是所有类都是直接间接的继承
继承 ：是对某一些类的抽象 java没有多继承

四种修饰符 ： public protected``default private

super注意：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super 必须出现在子类或者构造方法中
3. super() 和 this() 不能同时调用构造方法（因为都要求在首行调用）
   this注意：
4. 本身调用者的对象
5. this（）是本类的构造

方法的重写：（只和方法有关系）
需要有继承关系；子类重写父类方法；

1. 方法名相同
2. 参数列表相同
3. 子类修饰符 范围可以大，但不可以小

为什么重写：
父类功能：子类不一定需要，不一定满足。

// A 继承 B 
A a = new A();
a.print();

B b = new A();
b.print();

public class B{
	public void print(){
		sout"B";// 有static 和 没有static区别
	}
}
public class A extends B{
	public void print(){
		sout"A";
	}
}

b是 A new出来的对象，因此调用了A的方法。
因为静态方法是类的方法，非静态是对象的方法。
有static时，b调用了B类的方法，因为b是用b类定义的。
没有static时，b调用的是对象的方法，而b是用A类new的。

多态

// 一个对象的实际类型是确定的
new Person();
new Student();

// 可以指向的引用类型就不确定了：父类的引用指向子类

// Student 能调用的方法都是你自己的或者继承父类的
Student s1 = new Student();
// Person父类型，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();

//对象能执行哪些方法，主要看对象左边的类型和右边关系不大
s2.run();
s2.eat();

• 多态：

1. 多态是方法的多态，属性没有
2. 父类和子类，有联系 类型装换异常！ ClassCastException!
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！
   Father f1 = new Son();
   • static 方法，属于类，它不属于实例；
   • final 常量；
   • private 方法；
   • 以上三个不可以重写，所以没有多态。

• instanceof 测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型

• static
  加了static就是从属于这个类的，别人用不了。（不加static则属于对象）

public class Student{
	private static int age; // 静态变量
	private double score; // 非静态变量

	public static void main(String[] args){
		Student s1 = new Student();
		
		Student.age; // 静态才可以"类名.方法"进行访问
		s1.score;
	}
}

静态导入包
import static java.lang.Math.random;

• 抽象类
  在类上面使用abstract 抽象类

//抽象类
public abstract class Action(){
	//抽象方法
	public abstract void doSomething();
}

如果要继承一个抽象类，必须要重写抽象方法 @override
类是单继承，接口可以多实现
抽象类不能new出来抽象类，只能靠子类实现

• 接口
  普通类：具体实现
  抽象类：具体实现和规范（抽象方法）都有
  接口：只有规范！自己无法写方法~约束和实现分离！

接口中的所有定义都是抽象的public

public interface UserService{
	//接口定义 方法都是抽象的public （默认有 public abstract）
	void add(String name);
	//定义常量 public static final
}

public class UserServiceImpl implements UserService,TimeService{
	//子类实现用 implements
	@Override
	//重写方法
}

作用：

1. 约束
2. 定义一些方法，让不同对象实现
3. public abstract
4. public static final
5. 接口不能被实例化 接口中没有构造方法
6. implements 可以实现多个接口
7. 必须要重写接口中的方法

• 内部类
  一个java文件有多个class类，但是只能有一个public class类