java常忘的基础知识

java常忘的基础知识

Java两大数据类型

• 内置数据类型：又叫基本数据类型，主要包括如下几种

  类型	长度（bit）	默认值	取值范围
  byte	8	0	-128（-27）~127（27-1）
  short	16	0	-32768（-215）~32767（215-1）
  int	32	0	-2,147,483,648（-231）~2,147,483,647（231-1）
  long	64	0L	-263~263 -1
  float	32	0.0f	1.4E-45~3.4028235E38
  double	63	0.0d	4.9E-324~1.7976931348623157E308
  boolean	1	false	true/false
  char	16	0	0~65535

  **注意：**这里double和float其最小值时指的最小的正数，真正的最小值是负的最大值

  注意：局部变量是没有默认值的，只有实例变量和静态变量在声明时会有默认值

  这些最大值与最小值都包含再其对应类型的包装类中了，如int的最大值与最小值分别是：Integer.MAX_VALUE和Integer.MIN_VALUE;

  实际上，JAVA中还存在另外一种基本类型 void，它也有对应的包装类java.lang.Void，不过我们无法直接对它们进行操作

• 引用数据类型

  • 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
  • 对象、数组、字符串都是引用数据类型。
  • 所有引用类型的默认值都是null。
  • 一个引用变量可以用来引用任何与之兼容的类型。

实数精度

float只能保证十进制的6位运算，double只能保证十进制的15位运算

参考网址

常量的类型

常量	类型
0	int
0L	long
0.0	double
0.0f	float
true/false	boolean
‘a’	char
“a”	String

0开头表示八进制，0x表示十六进制

0明明是int，却可以赋值给byte？？？

这个问题似乎是编译器解决的：

• 猜想1：他会根据左值的类型来自动变化常量的类型，当左值是byte时，右值常量也会变成byte
• 猜想2：在赋值的时候，整数常量的类型是动态变化的，在-127_{128之间是，作为byte，在-32768}32767之间时，作为short，但常数默认是int类型的

参数传递

Java采用值传递。如果参数是引用数据类型，那么传过去的就是引用，还是可以通过引用来访问到实参所指向的对象的。

假除法

Java中整数类型的数据进行除法，得到的还是整形，且不会四舍五入，而是直接丢弃小数部分

即：1/2==0

类型转换

在进行类型转换的时候，可能会发生精度丢失或溢出

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

低  ------------------------------------>  高
byte,short,char—> int —> long—> float —> double 

强制类型转换

条件是转换的数据类型必须是兼容的，例如继承关系。

语法：(type)value

语法块

使用大括号括起来的部分

成员方法和变量的位置

成员方法和变量位置不重要，只要在该类中，都是可以使用的。不是必须在前面声明定义才能使用

访问控制

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N（说明）	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

三目运算符

语法：

variable x = (expression) ? value if true : value if false

例如

// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
b = (a == 1) ? 20 : 30;

判断类型instanceof

for each

语法：

for(声明语句 : 表达式)
{
   //代码句子
}

例如：

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}
/*
output：
10,20,30,40,50,
James,Larry,Tom,Lacy,
*/

switch

语法：

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

其中：

• value只能是常量或字面量
• 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。

int和Integer的区别

https://jingyan.baidu.com/article/c1465413e340760bfcfc4cd3.html

异常处理

语法：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

其中，finally无论有没有发生异常，都会执行

继承

需要注意的是 Java 不支持多继承（即一个子类继承多个父类），但支持多重继承（连续继承，如：C继承B，B继承A）

语法：

public class 子类名 extends 父类名 { 
    //类成员
}

特性：

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。如super.eat()，调用父类的eat方法

this关键字：指向自己的引用。

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

• 声明类：

  final class 类名 {//类体}
  

• 声明方法：

  修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
  

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

可变长参数

其类型是数组

语法：

void fun(int ...args)

注意事项如下：

1. 调用时，如果同时能匹配固定参数和可变长参数的方法，会优先匹配固定参数方法。

2. 如果能同时和2个包含可变参数的方法想匹配，则编译会报错，因为编译器不知道该调用哪个方法。

3. 一个方法只能有一个可变参数，且可变参数应为最后一个参数。

参考网址