CoreJava学习笔记01 基础

最新推荐文章于 2021-08-26 15:33:17 发布

迷途小年青

最新推荐文章于 2021-08-26 15:33:17 发布

阅读量438

点赞数

分类专栏： Java基础文章标签：学习笔记

本文链接：https://blog.csdn.net/qq_37224665/article/details/97617608

版权

Java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

CoreJava

学习方法

费曼学习法

确定目标（目标要足够明确）有什么样的目标
模拟教学（课堂反转，转教他人，90%的知识吸收率）
重复回顾代码量笔记（用自己的话把听懂的知识记下来）
概念简化

思维习惯行为习惯
学习能力（学会学习是最高级技能）

培训最终目的建立一个完整的知识体系
互联网精神（分享）
人类有史以来最卓越的编程语言 ----比尔盖茨
知其然，知其所以然。

Java

编程语言人机对话语法
机器语言 -------------> 自然语言

低级语言汇编语言
中级语言 C
高级语言 C++

java发展历程

1995年（Sun）Java

95.5.23 JDK1.0 96年推出的
98.12 JDK1.2 java2 J2SE J2ME J2EE
2001 TIOBE NO.1
2004 JDK1.5 JDK5 Java JavaSE JavaME JavaEE
2014 JDK1.8 JDK8

Java的主要特点

跨平台 Java应用可以部署在不同的操作系统上
简单
面向对象
开放开源
积累了大量的技术资源
强者恒强

计算机语言的运行机制

编译源代码 ------------> 机器码（编译器一次性把源代码翻译为机器码）运行效率高无法跨平台（C、C++)
解释源代码 ------------> （解释器逐行译为机器码，并运行）运行效率低可以跨平台 (脚本语言）

Java的运行机制

先编译后解释
源文件(.java)-----编译器-----> 字节码(.class)-----解释运行----->逐行运行

运行效率高可以跨平台

虚拟机屏蔽底层不同操作系统的差异，实现跨平台

字节
1B -128–127
2B -32768–32767
4B -2147483648–2147483647
8B -9223372036854775808–9223372036854775807

.class
解释器
JVM
操作系统

编译器+JVM+解释器+工具+类库=JDK

Hello.java

class A{
public static void main(String[] args){
	System.out.println("HelloWorld");
   }
}

  
编译 : javac Hello.java 
运行 : java A

配置三个环境变量

JAVA_HOME JDK安装目录告诉别人我的电脑上装有JDK，装在哪里
PATH JDK安装目录/bin 允许可以到其他目录下运行
CLASS_PATH =. 提示编译器JVM到哪里去找所需要的字节码文件

class（类）

Java组织代码的基本单位，每个类编译之后对应生成一个字节码文件

公开类所在的源文件的文件名必须和公开类名相同
主函数：Java代码的入口函数。执行一个类，只会执行这个类的主函数

public static void main(String[]args){}

一个源文件中可以定义多个类，但是只能定义一个公开类

java HelloWorld
java： 启动虚拟机  寻找HelloWorld.class

###package（包）
利用目录结构管理多个类

运用

java 包名.类名
javac -d . 源文件文件名

###import（导入包）
声明所用的类属于那个包，以便在程序中使用短类名

import java.util.*;  //表示所有类，不包括子包

如果有类名冲突，import无效
每个Java源程序默认添加 import java.lang.*;
java顶级结构
package 0-1个
import 0-n个
class 1-n个公开类 0-1个

Java编程习惯

1. 缩进

目的提升代码的可读性
习惯

每行只写一条语句
同级代码左对齐
每进入一个代码块缩进一次

2. 注释

目的为文件添加文件说明
习惯
1. //单行注释
2. /* /多行注释
3. /* */多行注释可以配合JavaDoc工具使用
编程习惯保证一定量的注释，做到代码注释到1:1
学习习惯

为老师的代码加上注释
删除老师的代码，根据注释还原代码
整体删除，重写老师代码

3. 标识符命名

由字母、数字、下划线、货币符号组成，其中数字不能开头
大小敏感，没有长度限制
不能使用Java中的关键字、保留字（goto、const）、特殊单词（true、false、null）

关键字
abstract assert do implements private throw boolean double import
protected throws break else enum instanceof public transient byte
extends int return case true false interfaceshort try catch final long
static void char finally native super volatile class float new switch
while continue for null synchronized default if package this

习惯

望文知义
大小写规则

程序元素	大小写规则	示例
类	单词首字母大写	HelloWorld
包	全小写	helloworld
变量 / 方法	首单词全小写，随后的单词首字母大写	helloWorld
常量	全大写	HELLOWORLD

变量和数据类型

强类型: 变量类型和数据类型保持一致
定义变量: 变量类型变量名
为变量赋值: 变量名=数据
访问变量: 直接用变量名访问

int a;
a=10;
System.out.println(a);//a=10
a=20;
System.out.println(a);//a=20
---------------------------------------
int a=10,b,c=20

数据类型

一、基本数据类型（原始类型、简单类型）

整形
1.byte 1Byte -128 – 127
2.short 2Byte -32768 – 32767
3.int 4Byte -2147483648 – 2147483647
4.long 8Byte -9223372036854775808 – 9223372036854775807 字面值加l或者L

int a = 10;
int a = 012;   //0开头，默认为8进制
int a = 0xA;   //0x开头，默认为16进制
int a = ab1010;//0b开头，默认为2进制  since7.0
long a = 12345678L;

00000000 0

01111111 127

10000000 -128

11111111 -1

浮点型
精度精确到小数点后多少位
5.float 4Byte 单精度字面值加f或F
6.double 8Byte 双精度字面值加d或D或不加
科学计数法 1.3*10^3 1.3e3

float 1符号位 8指数位 23尾数位
double 1符号位 11符号位 52尾数位

7.char 2Byte 字符字面值’A’ ‘\uoo41’
字符的编码每一个字符对应一个整数和整数类型可以交换使用

char c = '\u0041';
char c = 'A';
char c = 65;

A 65 a 97 0 48
ASCII 针对英语字符
国际化的字符集
Unicode 全球统一编码方式
UTF-16 以16位作为一个字符编码

转义字符

'\n' 换行
'\t' 水平跳格
'\'' 单引号
'\"' 双引号
'\\' 反斜杠

8.boolean 布尔类型字面值 true false
#####对象类型
String 字符串 “” 双引号

"a"+"b"="ab"
'a'+'b'=195

数据类型转换和提升

数据类型提升: 低字长整数赋值给高字长整形整数赋值给浮点数 float赋值给double
数据类型强转: 高字长整数赋值给低字长整数浮点数赋值给整数 double赋值给float short和char的相互赋值
boolean 类型不能参与任何不同类型的赋值和强转
基本类型和对象类型之间也不能发生赋值和强转

表达式与运算符

表达式

通过运算符，连接变量、常量和字面值，所形成的具有特定数值的运算符

表达式的数据类型（a+b）

如果a，b有String -------->String
否则如果a，b有double -------->double
否则如果a，b有float -------->float
否则如果a，b有long -------->long
否则 ---------------------------->int

#####运算符

数学运算符 + - * / %，整数除整数，结果还是整数

赋值运算符 = a=b 赋值表达式的值为b的值

 += -= *= /=  %=   （不会类型提升）a+=b<==>a=a+b(会发生类型提升)
 ++  --   a++<===>a+=1  a-- <===> a-=1
 a=4     a++表达式的值是4  ++a表达式的值是5

位运算符 &按位与 |按位或 ^按位异或 ~按位求反
>> >>> <<

 	1011		1011		1011
 	1110		1110		1110
 与  1010  或	1111 异或    0101

a ^ b = c 加密
c ^ b = a ^ b ^ b = b^ba= 0^a = a 解密

两个变量a b 交换值

c = a ; a = b; b=c;
a = a^b; b=a^b; a=a^b;
a2 = a ^ b
b2 = a2^b =a^bb = b^ba = 0^a =a
a3 = a2^b2 = a^ba = a^ab = 0^b = b

3) a=a+b; b=a-b; a =a-b;
a2=a+b
b2 = a2-b = a
a3 = a2-b2=a+b-a = b

比较运算符

== 等于 a==b

!= 不等于 a!=b

> < >= <=
逻辑运算符

&& 逻辑与并且 (a>b) && (c<d)

|| 逻辑或或者 (a>b) || (c<d)

! 逻辑非 !(a>b)

|| &&是短路运算符
| &是非短路运算符

三元运算符

(布尔表达式) ? 表达式1 : 表达式2 (a>b) ? 2 : 3

优先级

括号的优先级最高

java的流程控制

顺序执行按顺序执行每条语句

条件分支

if(布尔表达式){代码块}

if（布尔表达式）{代码块}
else{代码块}

if（布尔表达式）{代码块}
else if（布尔表达式）{代码块}
···
else{代码块}

switch(int 类型表达式){    // byte short int char
	case 值1： 代码块1 break；
	case 值2： 代码块2 break；
	...
	default：
}
switch（String） since JDK7

#####循环流程

while(布尔表达式){
代码块
}
循环0-n次


do{
代码块
}while（布尔表达式）；

循环1-n次


for（循环变量初始化；循环条件；循环变量步进）{
代码块
}
循环0-n次


for(int i = 1;i <= n; i++){}  循环n次
for(int i = 0;i < n; i++ ){}  循环n次

while 、do while不确定循环无法预计的循环次数
for 确定循环可以预计的循环次数

break 跳出循环
continue 跳出本次循环

abc :for(;;){}
给循环起名字abc
break abc  跳出确定的循环

局部变量

定义在方法/函数内部的变量

先赋值, 再使用. 系统不会为局部变量提供默认值
局部变量的作用范围: 从定义开始 , 到所在的代码块结束
在重合作用范围内, 不允许两个同名的局部变量同时出现

函数

实现了特定的功能的独立的代码过程

冗余代码,降低程序的可维护性

函数的语法

函数声明

必须在类以内, 任何函数以外

public static 返回值类型函数名 (形式参数列表)

形式参数: 约定调用该函数,所需要的参数类型和参数顺序 . 形参就是在函数内部有效的局部变量
函数实现

代码块 , 将函数中的所有代码编写在代码块中

return : 函数返回
函数调用

函数名(实际参数列表)

调用一个函数时, 程序流程会离开当前函数, 进入到目标函数 ; 从目标函数返回时, 返回到函数的调用点

实际参数: 调用函数时, 为形参赋值的数据

[外链图片转存失败(img-osHTV8Fx-1564309294584)(C:\Users\JIAOSH~1\AppData\Local\Temp\1563694777305.png)]

函数的作用

提高程序的可维护性, 减少冗余代码
提高程序的可重用性,

编程语言的基本单元:

语句汇编语言 CV复用
函数 C语言结构化编程函数库复用
类 Java语言面向对象编程类库复用, 接口复用

函数递归: 函数调用自身

把整体问题划分为若干局部问题, 局部问题的解法与整体问题同构

[外链图片转存失败(img-ZI1Z6RYS-1564309294585)(C:\Users\JIAOSH~1\AppData\Local\Temp\1563768107260.png)]

数组

数组的语法

一次性定义多个相同类型的变量

定义数组: 数据类型[] 数组名 int[] a ; int []a; int a[];
为数组分配空间 , 指定数组的长度: 数组名= new 数据类型[长度] a = new int[5];
访问数组元素: 数组名[下标] a[0] a[1] a[2] a[3] a[4] 下标范围: 0 - 数组长度-1
数组长度: 数组名.length a.length == 5

		int[] a ; 
		a = new int[5];
		//int[] a =new int[5];
		
		//遍历   访问数组中的每一个元素
		for(int i = 0 ; i < a.length ; i++){
			System.out.println(a[i]);
		}

数组元素, 在分配空间的时候, 自动被赋予默认值

根据数组类型数值类型为0 , 布尔类型为false , 对象类型为null
显式初始化

		int[] a ; 
		a = new int[]{2,3,5,8,6};
		// a = new int[5]{2,3,5,8,6};  error!
		// a = {2,3,5,8,6};  error!
		
		int[] b = new int[]{2,3,5,8,6};
		int[] c = {2,3,5,8,6};

数组的存储方式

数组元素在内存中的存储单元是连续的

好处: 便于查询 , 查询效率高下标从0开始, 也是为了提高寻址查询效率

坏处: 长度固定 , 插入删除效率低

数组的扩容:

二维数组

		//int[][] a = new int[3][4];
		//int[][] a = { {1,2,3,4},{5,6,7,8},{9,6,4,1} }; 
		
		int[][] a = new int[3][];
		a[0] = new int[4];
		a[1] = new int[5];
		a[2] = new int[3];
		
		//遍历a数组
		for(int i = 0 ; i < a.length ; i++){
			// 遍历a[i]数组
			for(int j = 0 ; j < a[i].length ; j++){
				System.out.print("a["+i+"]["+j+"]="+a[i][j]+"\t");
			}
			System.out.println();
		}

[外链图片转存失败(img-p2qAmSk7-1564309294586)(C:\Users\JIAOSH~1\AppData\Local\Temp\1563783335926.png)]

排序算法

冒泡排序 : 相邻的元素进行比较, 每次找出最大的元素

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

选择排序: 一个元素与剩余所有元素比较, 每次找出最小的元素

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

corejava学习笔记02 面向对象

迷途小年青

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
CoreJava学习笔记01 基础

CoreJava学习方法费曼学习法确定目标（目标要足够明确）有什么样的目标模拟教学（课堂反转，转教他人，90%的知识吸收率）重复回顾代码量笔记（用自己的话把听懂的知识记下来）概念简化思维习惯行为习惯学习能力（学会学习是最高级技能）培训最终目的建立一个完整的知识体系互联网精神（分享）人类有史以来最卓越的编程语言 ----比尔盖茨知其然，知其...
复制链接

扫一扫