java基础重点总结

最近重温一遍java基础，记录一些我认为重点或者容易忘的内容

1.JDK和JRE

  JRE(Java Runtime Environment)：是Java程序的运行环境，包含JVM和运行时所需要的核心类库。

  JDK(Java Development Kit): 是Java程序开发工具包，包括JRE和开发人员使用的工具。

2.命名规格（硬性要求）：

  标识符可以包含英文字母26个(区分大小写)、0-9数字 、$ (美元符号)和_ (下划线)。
  标识符不能以数字开头。
  标识符不能是关键字。

3.基本数字类型长度：

 4.数据类型转换

  4.1自动转换

  byte a = 1;

  int b = 2;

  a + b  结果类型自动转换为int

  自动转换:将取值范围小的类型自动提升为取值范围大的类型
  int a = 1;

  byte b = 2;

  b = a+ b;    //报错

  4.2强制转换

  强制类型转换：将 取值范围大的类型 强制转换成 取值范围小的类型 。

  short a = 1;

  a = a + 1;   //编译失败

  a = (short) a  + 1;  编译成功

5.1 += 运算符扩展

  short s = 1;

  s = s + 1;   //报错

  s += 1;   //成功   (等价于   s = (short) (s + 1))

  +=  会将结果类型强转为将要赋予变量的类型

5.2 常量和变量的运算

byte b1 = 1 ;

byte b2 = 2 ;

byte b3 = 1 + 2 ;   //编译成功  因为1和2是常量  编译时结果已经确定  没有超过byte  所以可以赋值给b3

byte b4 = b1 + b2 ;  //编译失败  因为b1和b2时变量，编译时无法确定  所以结果以int类型进行处理  赋值给b4报错

System . out . println ( b3 );

System . out . println ( b4 );

6.数组原理内存图

  Java虚拟机的内存划分

  

  数组在内存中的存储

  

两个变量指向一个数组

7.方法的参数类型区别

总结 :

方法的参数为基本类型时 , 传递的是数据值 . 方法的参数为引用类型时 , 传递的是地址值 .

8.为什么数组可以通过下标查询而链表不行

数组两个重要的特性：内存连续、类型相同

int[] arr = new int[10];   arr指向的是数组在内存中的起始地址。

因为数组时内存连续，并且类型相同，所以可以根据数组起始位置、下标和类型长度计算出对应下标的数据的地址，就可以直接拿出数据。

例如：数组存储的是int类型

所以数组可以通过数组起始地址、下标、存储类型长度根据一定的公式计算出指定下标元素的地址

而链表存储元素的内存是不连续的，当要查找指定元素时，只能从第一个元素一个一个的往下找。

9.面向对象思想

  概述：首先他是一种程序设计思想，也就是将现实事物的属性和特征抽象出来，描述成计算机事件的设计思想。而且区别于面向过程思想，强调的是调用对象来实现功能，而不是自己一步一步去操作实现。

10.类和对象的关系

  类是一类事物的描述，是抽象的。

  对象是一类事物的实例，是具体的。

  类是对象的模板，对象是类的实体。

11.对象内存图

两个对象，调用同一个方法内存图

12.成员变量和局部变量的区别

在类中的位置不同 重点

  成员变量：类中，方法外

  局部变量：方法中或者方法声明上(形式参数)

作用范围不一样 重点

  成员变量：类中

  局部变量：方法中

初始化值的不同 重点

  成员变量：有默认值

  局部变量：没有默认值。必须先定义，赋值，最后使用

在内存中的位置不同 了解

  成员变量：堆内存

  局部变量：栈内存

生命周期不同 了解

  成员变量：随着对象的创建而存在，随着对象的消失而消失

  局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

13.封装

  概述：封装可以被认为是一个保护屏障，让外界不可以随便访问类中代码和数据，只能通过指定的方式去访问。

14.String类

  特点：字符串的值在创建后不能改变。

String s1 = "abc"; 
s1 += "d"; 
System.out.println(s1); // "abcd" 
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

  常用方法：

public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。

public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

public int length () ：返回此字符串的长度。

public String concat (String str) ：将指定的字符串连接到该字符串的末尾。

public char charAt (int index) ：返回指定索引处的 char 值。

public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。

public String substring (int beginIndex) ：返回一个子字符串，从 beginIndex 开始截取字符串到字符串结尾。

public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从 beginIndex 到endIndex截取字符串。含 beginIndex ，不含 endIndex 。

public char[] toCharArray () ：将此字符串转换为新的字符数组。

public byte[] getBytes () ：使用平台的默认字符集将该 String 编码转换为新的字节数组。

public String replace (CharSequence target, CharSequence replacement) ：将与 target 匹配的字符串使用replacement 字符串替换。

public String[] split(String regex) ：将此字符串按照给定的 regex （规则）拆分为字符串数组。

15.static关键字

  static关键字可以用来修饰成员变量和成员方法，被修饰的成员属于方法。

  可以用来创建静态代码块

  static{

    //代码块内容，只在类加载的时候执行一次

  }

  静态原理图

static 修饰的内容：

是随着类的加载而加载的，且只加载一次。

存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。

它优先于对象存在，所以，可以被所有对象共享。

16.Arrays常用API

•   List<T> Arrays.asList(T... a)    //返回由指定数组支持的固定大小的列表。

   List<String> stooges = Arrays.asList("Larry", "Moe", "Curly"); 

•   void sort(int[] a)  //给指定的整型数据排序

17.Math类常用API

public static double abs(double a) ：返回 double 值的绝对值。

public static double ceil(double a) ：返回大于等于参数的最小的整数。

public static double floor(double a) ：返回小于等于参数最大的整数。

double d1 = Math.ceil(3.3); //d1的值为 4.0 
double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0 
double d3 = Math.ceil(5.1); //d3的值为 6.0

double d1 = Math.floor(3.3); //d1的值为3.0 
double d2 = Math.floor(‐3.3); //d2的值为‐4.0 
double d3 = Math.floor(5.1); //d3的值为 5.0

public static long round(double a) ：返回最接近参数的 long 。 ( 相当于四舍五入方法 )

十八.继承

   1.概述：继承描述的是类之间的所属关系，可以将一些类的公共属性和方法抽取出来，封装成一个父类，其他类只需要继承父类就可以用于公共的属性和方法。

  2.继承后成员变量重名，访问获取的是子类的值，如果需要获取父类的值，需要使用super关键字

class Fu { 
// Fu中的成员变量。 
int num = 5; 
}

class Zi extends Fu { 
// Zi中的成员变量 
int num = 6; 
public void show() { 
// 访问父类中的num 
System.out.println("Fu num=" + num); 
// 访问子类中的num 
System.out.println("Zi num=" + num); 
} 
}

class ExtendsDemo03 { 
public static void main(String[] args) { 
// 创建子类对象 
Zi z = new Zi(); 
// 调用子类中的show方法 
z.show(); 
} 
}


演示结果： 
Fu num = 6 
Zi num = 6

 3.使用super关键字调用与子类同名的父类成员变量

class Zi extends Fu { 
// Zi中的成员变量 
int num = 6; 
public void show() { 
//访问父类中的num 
System.out.println("Fu num=" + super.num); 
//访问子类中的num 
System.out.println("Zi num=" + this.num); 
} 
}
演示结果： 
Fu num = 5 
Zi num = 6

  4.当子类出现和父类重名的成员方法，则会重写父类的方法。

注意事项：子类方法重写父类方法时，必须要保证权限大于或等于父类。

  5.继承后特点---构造方法

子类无法继承父类的构造方法，但是子类初始化过程中必须调用父类的构造方法，子类构造方法默认有一个super（）（调用父类空参构造），用于调用父类的构造方法，父类的成员变量初始化后，才能给子类调用。

  6.super和this

super和this的含义
super ：代表父类的存储空间标识(可以理解为父亲的引用)。
this ：代表当前对象的引用(谁调用就代表谁)。

十九、接口

  1.类和接口

类封装构造方法、成员变量、成员方法

接口主要封装方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。 
静态方法：使用 static 修饰，供接口直接调用。   （只能接口直接调用）

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。（私用方法是对默认方法和静态方法的赋值，重复的代码可以抽取到一个私用方法中，供多个默认方法或者静态方法调用）

  2.优先级问题

当子类同时继承父类和实现接口，父类的成员方法和接口的默认方法重名时，子类调用会就近执行父类的成员方法。

提示：子类实现接口时，重写默认方法，default关键字不可保留；子接口继承父接口，重写默认方法，default关键字可以保留

  3.抽象类和接口的区别：

• 抽象类可以定义成员变量，接口中只能定义成员常量，默认以public static final修饰
• 抽象类可以有构造方法，接口不能有
• 抽象类可以有静态代码块，接口不能有（接口中只能由静态常量，定义的时候就已经赋值了，静态代码块通常时用来初始化成员变量的，接口不需要）

二十、多态

  1.概述

多态：指同一行为，具有多种不同变现形式。

  2.前提

• 继承或者实现
• 方法重写
• 父类引用指向子类引用

二十二、权限修饰符

二十三、内部类

  内部类可以直接调用外部类的成员变量，包括私有变量。

  外部类想要调用内部类的成员变量，需要先创建内部类对象

  创建内部类格式：外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

public class Person { 
private boolean live = true; 

class Heart { 
    public void jump() { 
    // 直接访问外部类成员 
    if (live) { 
        System.out.println("心脏在跳动"); 
    } else { 
        System.out.println("心脏不跳了"); 
        } 
    } 
}

public boolean isLive() { 
    return live; 
}
public void setLive(boolean live) { 
    this.live = live; 
} 
}


public demo(){

    public static void main(String[] args) { 
        // 创建外部类对象 
        Person p = new Person(); 
        // 创建内部类对象 
        Heart heart = p.new Heart(); 
        // 调用内部类方法 
        heart.jump(); 
        // 调用外部类方法 
        p.setLive(false); 
        // 调用内部类方法 
        heart.jump(); 
    } 
}
输出结果: 
心脏在跳动 
心脏不跳了