JavaSE篇—Day(1、2)笔记

Day（1）笔记

一、计算机基础

1.计算机概述

计算机全称为：电子计算机，俗称电脑

2.计算机硬件和软件概述

• 计算机硬件是指计算机系统中由电子，机械和光电元件等组成的各种物理装置的总称。
• 计算机软件是指使用计算机过程中必不可少的东西，计算机软件可以使家算计按照事先预定好的顺序完成特定的功能，计算机软件按照其功能划分为系统软件和应用软件。

3.软件开发和计算机语言概述

• 软件开发：借助开发工具与计算机语言制作软件。
• 计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言。
• 常见的计算机语言如C，C++，C#，JAVA，python。

4.人机交互

交互方式：

• 图形化界面：这种方式简单直观，使用者易于接受，容易操作上手。
• 命令性方式：需要一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦。需要记录住一些命令。

5.键盘功能键和快捷键

应该记住一些简单的功能键和快捷键

• Tab 缩进空格
• Enter 回车
• Window键
• Ctrl+A全选 Ctrl+C 复制 Ctrl+V 粘贴 Ctrl+X剪切 Ctrl+Z 撤销 Ctrl+S 保存

6.如何打开DOS控制台

Windows+R -> cmd -> 回车

7.常见的DOS讲解

• d: +回车 盘符切换
• dir(directory): 列出当前目录下的文件以及文件夹
• md(make directory): 创建目录
• rd(remove directory): 删除目录
• cd(change directory): 改变指定目录（进入指定目录）
• cd..: 退回上级目录
• cd\: 退回根目录
• exit: 推出dos命令行
• cls(clear screen): 清屏
• del(delete): 删除文件，删除一堆后缀名一样的文件，例如.txt

二、Java语言基础

1.Java语言概述

Java语言由詹姆斯.高斯林发明

2.Java语言跨平台原理

Java是面向对象的语言，其重点特点是开源和跨平台

3.JDK与JRE的概述

JRE -> Java运行环境

JDK -> Java开发工具包，其中包含了JRE

简单而言：使用JDK开发完成的java程序，交给JRE去运行

4.JDK的下载、安装和卸载

详情请看：https://blog.csdn.net/nuoyanli/article/details/86513950

5.Java环境变量的配置

详情请看：https://blog.csdn.net/nuoyanli/article/details/86513950

6.第一个Java案例的编写和运行

视频里老师用的是记事本进行编写和运行，而我用的是Eclipse Jee 2018-12

import java.util.*;
import java.math.*;
import java.io.*;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
        System.out.println("Hello world");
 }
}

 

Day（2）笔记

Java基础语法

1.关键字

关键字概述：
被Java语言赋予特定含义的单词。

关键字特点：
组成关键字的字母全部小写。

注意事项：
goto和const是保留字，在一般的高级Java编译器中，针对关键字都有特殊的颜色标记。

• Java关键字

 

2.标识符

标识符概述：
就是给类，接口，方法，变量等起名字时使用的字符序列

组成规则：

• 英文大小写字母
• 数字字符
• $和_

注意事项：

• 不能以数字开头
• 不能是Java中的关键字
• 区分大小写

3.标识符的常见命名规则

注意事项：
见名知意

• 举例：我要定义一个学生类

class Student {}

单级：liuyi包：
其实就是文件夹，用于把相同的类名进行区分，全部小写

• 多级：cn.itcast

类或者接口：

• 一个单词：单词的首字母必须大写,举例：Student，Dog
• 多个单词：每个单词的首字母必须大写，举例：HelloWorld，StudentName

方法或者变量：

• 一个单词：单词的首字母小写，举例：main，age
• 多个单词：从第二个单词开始，每个单词的首字母大写，举例：studentAge,showAllNames

常量：

• 一个单词组成：全部大写，举例：PI
• 多个单词组成：每个字母都大写，用_隔开，举例：STUDENT_MAX_AGE

4.注释概述及其分类

注释概述：
用于解释说明的文字

Java中注释分类格式：

• 单行注释：格式：//注释文字
• 多行注释：格式：/星 注释文字 星/，注意：多行不可以嵌套使用，而单行是可以的
• 文档注释：格式：/星星 注释文字 星/

5.HelloWorld案例加入注释

/*
 需求：我准备写一个java程序，把"HelloWorld"这句话输出在控制台

分析：
A:要写一个Java程序，必须定义类
B:把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法
C:把数据输出在控制台，必须使用输出语句
实现：
A:java语言提供了一个关键字：class用来定义类，后面跟的是类名
B:main方法的格式是固定的：
public static void main(String[] args) {

}
C:输出语句的格式是固定的：
System.out.println("HelloWorld");
"HelloWorld"这个内容是可以改变的
*/

//这是我的HelloWorld案例
class HelloWorld {
/*
为了程序能够独立运行，定义main方法
main方法是程序的入口
被jvm自动调用
*/
public static void main(String[] args) {
  //为了把数据显示在控制台，我们就使用了输出语句
 System.out.println("HelloWorld");
  }
}

6.注释的作用
略过，在Eclipse Jee 2018-12程序中编写Java代码时，有错误的话，编译器会提示。

7.常量的概述和使用

常量概述：
在程序执行的过程中其值不可以发生改变

/*
    常量：
        在程序执行过程中，其值不发生改变的量。

    分类：
        A:字面值常量
        B:自定义常量(后面讲)

    字面值常量
        A:字符串常量  用双引号括起来的内容。
            举例："hello","world","HelloWorld"
        B:整数常量   所有的整数
            举例：100,200
        C:小数常量   所有的小数
            举例：10.23,110.11
		D:字符常量	用单引号括起来的内容
			举例：'a','A','0'
			错误的：'ab'
		E:布尔常量	比较特殊
			举例：true,false
		F:空常量	后面讲
			举例：null
*/
class ConstantDemo {
	public static void main(String[] args) {
		//字符串常量的输出
		System.out.println("hello");
		
		//整数常量的输出
		System.out.println(100);
		
		//小数常量的输出
		System.out.println(100.10);
		
		//字符常量的输出
		System.out.println('a');
		System.out.println('A');
		System.out.println('0');
		//这个是有问题的
		//System.out.println('ab');
		
		//布尔常量的输出
		System.out.println(true);
		System.out.println(false);
	}
}

8.进制概述以及二进制、八进制、十六进制图解

 

二进制->八进制：
把二进制的数据，从右开始，每三位一组合，最左边不够的时候，补0。然后，分别计算出对应的十进制数值，最后，再把每个十进制的数据组合起来，就是一个八进制数据。

二进制->十六进制：
把二进制的数据，从右开始，每四位一组合，最左边不够的时候，补0。然后，分别计算出对应的十进制数值，最后，再把每个十进制的数据组合起来，就是一个十六进制数据。

规则：进制越大，表现形式越短

9.不同进制数据的表现形式

/*
	不同进制的数据表现：
		二进制：由0，1组成。以0b开头。
		八进制：由0,1,...7组成。以0开头。
		十进制：由0,1,...9组成。默认整数是十进制。
		十六进制：由0,1,...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。
*/
class JinZhiDemo {
	public static void main(String[] args) {
		System.out.println(100); //十进制
		
		System.out.println(0b100); //二进制
		System.out.println(0100); //八进制
		System.out.println(0x100); //十六进制
	}
}

10.任意进制到十进制的转换

 

系数：每一个位上的数据值本身就是系数。

基数：x进制的基数就是x。

权：我们针对每一个位上的数据进行编号，从右边，并且是从0开始编号，这个编号就是该位上数据的权值。

PS：每一个位上的系数x基数^权次幂相加。

11.十进制到任意进制的转换

方法：这个数对基数依次取余，将余数倒序输出，在倒序输出余数之前正序输出最后一次的商。（这个方法是很简单的一种方式，可以大大的节省时间）。

将十进制转成八进制：
579 / 8 = 72　．．．3
72 / 8 =9　．．．0
9 / 8 =1　．．．1

先输出最后一次计算的商，然后倒序从下到上输出余数
八进制的 576 为　1103

12.快速的进制转换法

8421码

13.原码、反码、补码的讲解

在探求为何机器要使用补码之前, 让我们先了解原码, 反码和补码的概念.对于一个数, 计算机要使用一定的编码方式进行存储. 原码, 反码, 补码是机器存储一个具体数字的编码方式。

原码：
原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:

[+1]原 = 0000 0001

[-1]原 = 1000 0001

第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:[1111 1111 , 0111 1111]即[-127 , 127]，原码是人脑最容易理解和计算的表示方式。

反码：
反码的表示方法是:正数的反码是其本身；负数的反码是在其原码的基础上, 符号位不变，其余各个位取反。

[+1] = [00000001]原 = [00000001]反

[-1] = [10000001]原 = [11111110]反

可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。

补码：
补码的表示方法是:正数的补码就是其本身；负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)。

[+1] = [00000001]原 = [00000001]反 = [00000001]补

[-1] = [10000001]原 = [11111110]反 = [11111111]补

对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值。

14.变量的概述及格式

变量的概念：

• 在程序执行的过程中，在某个范围内其值可以发生改变的量

• 从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容），才能使用。

变量定义格式：

• 数据类型 变量名 = 初始化值;

注意：格式是固定的，记住格式，以不变应万变

15.数据类型的概述和分类和定义不同数据类型的变量

/*
	数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。
	
	数据类型分类：
		A:基本数据类型
		B:引用数据类型(类,接口,数值)
		
	基本数据类型:4类8种
		A:整数			占用字节数
			byte			1
			short			2
			int				4
			long			8
			
		B:浮点数
			float 			4
			double 			8
			
		C:字符
			char			2
		D:布尔
			boolean			1
		
		注意：
			整数默认是int类型
			浮点数默认是double类型。
			
			长整型后缀用L或者l标记。建议使用L。
			单精度浮点数用F或者f标记。建议使用F。
*/
class DataTypeDemo {
	public static void main(String[] args) {
		//定义变量的格式：
		//数据类型 变量名 = 初始化值;
		
		//定义一个字节变量
		byte b = 10;
		System.out.println(10);
		System.out.println(b);
		
		//定义一个短整型变量
		short s = 100;
		System.out.println(s);
		
		//定义一个整型变量
		int i = 1000;
		System.out.println(i);
		
		//超过了int的范围
		//int j = 1000000000000;
		long j = 1000000000000L;
		//long j = 100L;
		System.out.println(j);
		
		//定义浮点数据变量
		float f = 12.345F;
		System.out.println(f);
		
		double d = 12.345;
		System.out.println(d);
		
		//定义字符变量
		char ch = 'a';
		System.out.println(ch);
		
		//定义布尔变量
		boolean flag = true;
		System.out.println(flag);
	}
}

 

16.使用变量的注意事项

/*
	使用变量的时候要注意的问题：
		A:作用域
			变量定义在哪个大括号内，它就在这个大括号内有效。
			并且，在同一个大括号内不能同时定义同名的变量。
			
		B:初始化值
			没有初始化值的变量不能直接使用。
			你只要在使用前给值就行，不一定非要在定义的时候立即给值。
			推荐在定义的时候给值。
			
			定义变量的格式：
				a:数据类型 变量名 = 初始化值;
				b:数据类型 变量名;
				  变量名 = 初始化值;
		
		C:在一行上建议只定义一个变量
			可以定义多个，但是不建议
*/
class DataTypeDemo2 {
	public static void main(String[] args) {
		//定义变量
		int x = 100;
		
		//错误，不能有同名的
		//int x = 200;
		
		//定义变量必须给值
		//int y;
		//System.out.println(y);
		
		int z;
		z = 100;
		System.out.println(z);
		
		//在一行上定义多个变量
		//int a = 10; int b = 20; int c  = 30;
		//上面的写法可以，但是不建议。
		int a = 10;
		int b = 20;
		int c  = 30;
		
		//int d, e;
		//d = 40;
		//e = 50;
		
		//int f,int g; //错误
		//int h; int i; //正确
	}
}

17.数据类型转换默认转换

/*
	+是一个运算符(我们等会讲解)。做加法运算的。
	
	一般来说，我们在运算的时候，要求参与运算的数据类型必须一致。
	
	注意：
		boolean类型不能转换为其他的数据类型

	默认转换(从小到大的转换)
		A:byte,short,char—int—long—float—double
		B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型
*/
class DataTypeDemo3 {
	public static void main(String[] args) {
		//直接输出的方式做加法
		//System.out.println(3 + 4);
	
		//两个int类型做加法
		int x = 3;
		int y = 4;
		int z = x + y;
		System.out.println(z);
		
		//定义一个byte类型，一个int类型，做加法
		byte a = 3;
		int b = 4;
		System.out.println(a + b);
		
		//可能损失精度
		//byte c =  a + b;
		int c = a + b;
		System.out.println(c);
	}
}

18.数据类型转换强制转换

/*
	强制转换：
		从大的数据类型到小的数据类型。
		
		格式：
			目标数据类型 变量 = (目标数据类型) (被转换的数据);
			
		注意：
			不要随意的去使用强制转换，因为它隐含了精度损失问题。
*/
class DataTypeDemo4 {
	public static void main(String[] args) {
		byte a = 3;
		int b = 4;
		
		//这个肯定没有问题
		//int c = a + b;
		
		//byte c = 7;
		//这个是有问题的
		//byte c = a + b; 
		//用强制类型转换改进
		byte c = (byte) (a + b);
		System.out.println(c);
	}
}

19.强制转换的思考题

/*
	思考题1：请问下面这个有没有问题
		double d = 12.345;
		float f = d;
		
	思考题2：看看下面两个定义有没有区别呢?
		float f1 = (float)12.345;
		float f2 = 12.345f;
		
		f1其实是通过一个double类型转换过来的。
		而f2本身就是一个float类型。
*/
class DataTypeDemo5 {
	public static void main(String[] args) {
		//把double赋值给float，加了强制类型转换
		double d = 12.345;
		float f = (float)d;
		
		//看看下面两个定义有没有区别呢?
		float f1 = (float)12.345;
		float f2 = 12.345F;
	}
}

20.变量相加和常量相加的面试题

/*
	面试题：
		byte b1=3,b2=4,b;
		b=b1+b2;
		b=3+4;
		哪句是编译失败的呢？为什么呢？
		b = b1 + b2;是有问题的。
		因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。
		常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
*/
class DataTypeDemo6 {
	public static void main(String[] args) {
		//定义了三个byte类型的变量，b1，b2，b3
		//b1的值是3，b2的值是4，b没有值
		byte b1 = 3,b2 = 4,b;
		
		//b = b1 + b2; //这个是类型提升，所以有问题
		
		b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。
	}
}

21.强制转换数据溢出后的结果怎么算

/*
	byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
	
	练习：byte b = (byte)300;
*/
class DataTypeDemo7 {
	public static void main(String[] args) {
		//因为byte的范围是：-128到127。
		//而130不在此范围内，所以报错。
		//byte b = 130; 
		
		//我们可以使用强制类型转换
		byte b = (byte) 130;
		
		//结果是多少呢?
		System.out.println(b);
	}
}
/*
	分析过程：
		我们要想知道结果是什么，就应该知道是如何进行计算的。
		而我们又知道计算机中数据的运算都是补码进行的。
		而要得到补码，首先要计算出数据的二进制。
		
		A:获取130这个数据的二进制。
			00000000 00000000 00000000 10000010
			这是130的原码，也是反码，还是补码。
		B:做截取操作，截成byte类型的了。
			10000010 
			这个结果是补码。
		C:已知补码求原码。
					符号位		数值位
			补码：	1			0000010
			
			反码：	1			0000001
			
			原码：	1			1111110
*/

22.字符数据参与运算

常用字符与ASCII代码对照表

23.字符串参与运算

/*
	看程序写结果
		字符串数据和其他数据做+，结果是字符串类型。
		这里的+不是加法运算，而是字符串连接符。
*/
class DataTypeDemo9 {
	public static void main(String[] args) {
		System.out.println("hello"+'a'+1); //helloa1，因为有优先级
		System.out.println('a'+1+"hello"); //98hello
		
		System.out.println("5+5="+5+5); //5+5=55
		System.out.println(5+5+"=5+5"); //10=5+5
	}
}

运算符优先级