JavaSE-基础篇学习笔记分享（一）

自学玩家
279 阅读12分钟

笔记整理自B站尚硅谷JavaSE视频，其中可能有记录内容不正确，望诸位指出

作者：Vison

1、JDK JRE JVM

JVM > JRE > JDK jdk = jre + 开发工具集
jre = jvm + JavaSE标准类库

JDK(Java Development Kit Java开发工具包)

JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE，所以安装了JDK，就不用再单独的安装JRE了

JRE(Java Runtime EnvironmentJava运行环境)

包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可

2、变量

  • 数据类型
  • 基本数据类型
    • 数值型
      • 整数类型(byte,short,int,long)
      • 浮点类型(float,double)
    • 字符型(char)
    • 布尔型(boolean)
  • 引用数据类型
    • 类(class) <----字符串在这里
    • 接口(interface)
    • 数组( [ ] )

所有变量

在方法体外，类体中声明的变量称为成员变量
在方法体内部声明的变量称为局部变量

  • 成员变量
    • 实例变量(不以static修饰)
    • 类变量(以static修饰)
  • 局部变量
    • 形参(方法，构造器中定义的变量)
    • 方法局部变量(方法内定义)
    • 代码块局部变量(代码块内定义) 注意：两者在初始化值方面的异同
      同：都有声明周期
      异：局部变量除形参外，需显示初始化

整数类型：byte、short、int、long

java的整型常量默认为int型，声明long型常量须后加I或L
java程序中变量通常声明为int型，除非不足以标识较大的数才使用long

类型占用存储空间表数范围
byte1字节=8Bit位-128 ~ 127
short2字节-2的15次方 ~ 2的15次方 - 1
int4字节-2的31次方 ~ 2的31次方 - 1
Long8字节-2的63次方 ~ 2的63次方 - 1

浮点类型：float、double

java中的浮点型常量默认为double类型，声明float型常量，须后加“f”或“F”

类型占用存储空间表数范围
单精度float4字节-3.403E38 ~ 3.403E38
双精度double8字节-1.798E308 ~ 1.798E308

3、运算符

位运算符

运算符运算
<<左移
>>右移
>>>无符号右移
&与运算
竖(markdown语法问题不会打)或运算
异或运算
~取反运算

逻辑运算符

aba&ba&&ba竖ba竖竖b!a!b
truetruetruetruetruetruefalsefalse
truefalsefalsefalsetruetruefalsetrue
falsetruefalsefalsetruetruetruetrue
falsefalsefalsefalsefalsefalsetruefalse

&和&&的区别 &左边无论真假，右边都进行运算
&&如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算
|和||的区别 |同理
||左边为真右边不参与运算

比较运算符

image.png

赋值运算符

=

算术运算符

image.png

4、程序流程

if-else

seitch-case

for循环

while循环

do-while循环

break、continue、return

5、数组

一维数组

image.png

二维数组

例子： int[][] arr = new int [3][2];

数组中常见的算法

数组线性查找

String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
String dest = "BB";
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
	if(dest.equals(arr[i])){
    	sout("找到了元素");
        isFlag = false;
		break;
    }
}
if(isFlag){
 	sout("没找到")   
}

二分法查找

//前提所要查找的数组必须有序
int[] arr = new int[]{-12,-1,0,2,4,8,9,12,45,78,153,952};
int dest = 4;
int head = 0;//初始的首索引
int end = arr.length - 1;//初始的末索引
boolean isFlag = true;
while(head <= end){
    int middle = (head + end) / 2;
    if(dest == arr[middle]){
    	sout("找到了指定元素");
        isFlag = false;
        break;
    }else if(arr[middle] > dest){
    	end = middle -1;
    }else{
      	head = middle + 1;
    }
}

冒泡排序

int[] arr = new int[]{56,12,45,32,6545,213,45,123,45,20};

for(int i = 0;i < arr.length - 1,i++){
	for(int j = 0;j < arr.length - 1 - i;j++){
    	if(arr[j] > arr[j + 1]){
        	int temp = arr[j];
        	arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

快速排序

public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0);
				while (high > start && data[--high] - base >= 0);
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

6、类

创建对象语法：
类名 对象名 = new 类名();
使用“对象名。对象成员”的方式访问对象成员(包括属性和方法)

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
Inner class的名字不能与包含它的外部类类名相同:
分类:
成员内部类(static成员内部类和非static成员内部类)
局部内部类(不谈修饰符)、匿名内部类

成员内部类作为类的成员的角色和外部类不同，
Inner class还可以声明为 private 或 protected :可以调用外部类的结构
Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量
成员内部类作为类的角色:
可以在内部定义属性、方法、构造器等结构
可以声明为abstract类，因此可以被其它的内部类继承
可以声明为final的
编译以后生成OuterClassSInnerClass.class字节码文件(也适用干局部内部类)

【注意】
1.非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员 内部类中才可声明static成员。
2.类访问成员内部类的成员，需要“内部类.成员”或“内部类对象成员”的方式
3、成员内部类可以直接使用外部类的所有成员，包括私有的数据。
4.当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态时

局部内部类的特点

  1. 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
  2. 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
  3. 局部内部类可以使用外部类的成员，包括私有的。
  4. 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
  5. 局部内部类和局部变量地位类似，不能使用publicprotected，缺省，private
  6. 局部内部类不能使用static修饰，因此也不能包含静态成员

匿名内部类

image.png

7、抽象类抽象方法

用abstract修饰一个类，这个类叫做抽象类

用abstract修饰一个方法，该方法叫做抽象方法 只有方法的声明，没有方法的实现，以分号结束 public abstract void talk();

抽象类不能实例化
抽象类可以被继承

不能用abstract修饰变量，代码块，构造器

不能用abstract修饰私有方法，静态方法，final的方法

8、接口和抽象类的对比

9、代码块

代码块的作用： 类或者对象的初始化

静态代码快

静态代码块：用static修饰的代码块

可以有输出语句

可以对类的属性，类的声明进行初始化操作

不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法

若有多个静态的代码块，那么按照从上到下的顺序依次执行

静态代码块的执行要先于非静态代码块

静态代码块随着类的加载而加载，且只执行一次

非静态代码块

非静态代码块：没有static修饰的代码块

可以有输出语句

可以对类的属性，类的声明进行初始化操作

除了调用非静态的结构外，还可以调用静态的变量或方法

若有多个非静态的代码块，那么按照从上到下的顺序依次执行

每次创建对象的时候都会执行一次，且先于构造器执行

10、对象内存解析

image.png

image.png

11、属性

修饰符 数据类型 属性名 = 初始化值；

属性的赋值过程

image.png

程序中成员变量的执行顺序

image.png

12、构造器

构造器的特征
   他具有类相同的名称
   他不声明返回值类型
   不能以static、final、synchronized、abstract、native修饰，不能有return语句返回值
   语法格式：
       修饰符 类名(参数列表){
           初始化语句；
       }

构造器的作用 创建对象，给对象进行初始化

根据参数不同，构造器可以分为如下两类:

隐式无参构造器(系统默认提供)
显式定义一个或多个构造器(无参 有参) 注 意:
Java语言中，每个类都至少有一个构造器默认构造器的修饰符与所属类的修饰符一致 一日显式定义了构造器，则系统不再提供默认构造器一个类可以创建多个重载的构造器 父类的构造器不可被子类继承

构造器重载

构造器重载，形参列表必须不同

构造器重载方便创建各种不同的对象

13、方法

    方法的声明格式
    修饰符 返回值类型 方法名 (参数类型 形参1 ，......){
        方法体程序代码
        return 返回值；
    }
无返回值有返回值
无形参void方法名(){}返回值类型 方法名(){}
有形参void方法名(形参列表){}返回值类型 方法名(形参列表){}

方法的重写

重写的概念：在子类中可以根据需要对父类中继承来的方法进行改造，也称为方法的重置，覆盖，在程序执行时，子类的方法将覆盖父类的方法

要求：

  • 子类重写的方法必须和父类被重写的方法具有相同的方法名，参数列表
  • 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
  • 子类重写的方法的使用的访问权限不能小于父类中被重写的方法的访问权限，子类不能重写父类中声明为private权限的方法
  • 子类方法抛出的异常不能大于父类被重写方法的异常

注意： 子类与父类中同名同参数的方法必须同事声明为非static的，或者同时声明为static的，因为static方法属于类，子类无法覆盖父类的方法

方法的重载

重载的概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可

重载的特点：与返回类型无关，只看参数列表，且参数列表必须不同

举个例子

//返回两个整数的和
int add(int x, int y){
	return x + y;
}
//返回三个整数的和
int add(int x, int y, int z){
	return x + y + z;
}
//返回两个小数的和
double add(double x,double y){
	return x + y;
}

可变个数的形参

说明:

  1. 声明格式:方法名(参数的类型名 ...参数名)
  2. 可变参数:方法参数部分指定类型的参数个数是可变多个:0个，1个或多个
  3. 可变个数形参的方法与同名的方法之间，彼此构成重载
  4. 可变参数方法的使用与方法参数部分使用数组是一致的
  5. 方法的参数部分有可变形参，需要放在形参声明的最后
  6. 在一个方法的形参位置，最多只能声明一个可变个数形参

方法的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数:形参:方法声明时的参数 实参:方法调用时实际传给形参的参数值

Java的实参值如何传入方法呢? Java里方法的参数传递方式只有一种:值传递。 即将实际参数值的副本(复制品)传入方法内，而参数本身不受影响。

形参是基本数据类型:将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型:将实参引用数据类型变量的“地址值”传递给形参

14、接口

有时，必须从几个类中派生出一个子类，继承他们所有的属性和方法名单时java不支持多继承，有了接口就可以的到多继承的效果

有时，必须从几个类中抽取出一些共同的行为特征，而他们之间没有is-a的关系，不仅仅是具有相同的行为特征而已， 如鼠标，键盘，打印机，扫描仪，摄像头，充电器，都有USB连接

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能....”的思想，继承是一个“是不是”的关系，而接口实现是“能不能”的关系。

接口的本质是契约，标准，规范，就像我们的法律一样

接口(interface)是抽象方法和常量值定义的集合

接口的特点:

  • 用interface来定义
  • 接口中所有的成员变量都默认由public static final修饰的
  • 接口中所有抽象方法都默认是public abstract修饰的
  • 接口中没有构造器
  • 接口采用多继承机制

接口定义举例

定义java类的语法格式：

先写extends 后写implements

一个类可以实现多个接口，接口也可以继承其他接口

实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化，否则仍为抽象类

接口的主要用途就是被实现类实现

与继承关系类似，接口与实现类之间存在多态性

接口和类似并列关系，或者可以理解为一种特殊的类，从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现

avatar
文章
阅读
粉丝