动力节点笔记_public class a{public static viod main(string[]arg-CSDN博客

本文链接：https://blog.csdn.net/weixin_49555136/article/details/107584832

一.DOS命令

cd(空格) 切换目录改变目录
相同盘符切目录（cd+路径）
不同盘符切目录（cd+路径D:…）+（D：）

           绝对路径：从根目录（磁盘盘符)作为出发点的路径  
                  C:\Users\木子文三金>cd C:\Users\木子文三金\Desktop
           相对路径：从当前所在路径作为出发点的路径  
                  C:\Users\木子文三金>cd Desktop

c: d: 切换盘符(c:) （ d：）
cls 清屏
exit 退出
mkdir 新建文件夹
cd … 回到上级目录：【…是一个路径，代表当前路径的上级路径】
cd …/…/…/
cd \ 直接回到根路径
ctrl + c 强行终止DOS命令窗口中正在运行的程序
dir 查看当前目录下所有的子文件和子目录
regedit 打开注册表
ipconfig 可以查看更详细的IP信息，这种查看方式可以看到网卡的物理地址。
物理地址具有全球唯一性。是在生产网卡的时候，嵌入的编号。

* HOME					 回到行首
* END	                 回到行尾											
* shift + home	         选中光标前一行
* shift + end	         选中光标后一行
* ctrl + shift + 箭头    选中一个单词
* 鼠标双击               选中一个单词
* 鼠标三击               选中一行
* ctrl + end	         回到文件末尾
* ctrl + home	         回到文件头

二.文件扩展名：.java

三.语言特性：【开源免费纯面向对象跨平台】
java：不支持多继承屏蔽了指针
C++：支持多继承有指针
Java语言底层是靠C++实现的，不是C语言
四.Jave的加载与执行
1.加载（javac）：.java----.class
2.执行（java）：打开DOS命令窗口
输入：java Ａ{中间一定加空格}

				  java.exe会启动java虚拟机（JVM）
				  JVM启动类加载器classLoader
				  classLoader回去硬盘上搜索A.class文件，找到该文件将字节码文件装载到JVM当中
				  JVM将字节码文件解释成二进制101010101010这样的的数据
				  然后操作系统将二进制和底层硬件平台进行交互
				 【先将DOS窗口中的目录切换到HelloWorld.class文件所在目录
			   （输入“cmd”，回车），然后直接执行，java HelloWorld（没有.java)】

3.HelloWorld 程序
public class HelloWorld{
public static void main(string[]args){
System.out.println(“HelloWorld!”);
}
}
4.
编译Java文件为class文件 Javac（空格） HelloWorld.java
运行class文件 java（空格） HelloWorld

5.javac -d. Test1.java 调用包的命令

五.标识符
1.标识符可以识别哪些元素？
类名，方法名，常量名，变量名，接口名。
2.标识符的命名规则?
1.只能由字母，数字，下划线，美元符组成，不能含有其他特殊符号；
2.不能以数字开头
3.严格区分大小写
4.关键字（蓝色字体）不能做标识符
5.理论上无长度限制，但最好不要太长
规范：（3）标识符的命名规则？【只是一种规范，不属于语法，不遵守规范编译器不会报错】
*最好见名知意
public class Userservice{
public void login(String username,String password){
}
}
*遵守驼峰命名法
SystemService
UserService
CustomerService

*类名、接口名：首字母大写，后面每个单词首字母大写。（类接大大）
*变量名、方法名：首字母小写，后面每个单词首字母大写。（方便小大）
*常量名：全部大写。

六.Java常用单词
public：公共的；公开的
class:种类
static:静态的;静止的
void:空白
if:条件；假设
for:由于：对于；以…为交换
while:当…的时候；和…同时
do:
default:不履行；违约
byte:字节
short:短的
int:C语言通常使用 int 来定义整数（int 是integer 的简写）

  long:C语言的一个关键字，代表一种数据类型
       long是long int的简写，也就是说，在C语言中long int类型和long类型是相同的
       long是长整形；一般的int型是2字节，long型是4字节的，就是说long型的数据能表示的数值更大一些。
      每个long型占4个字节，在32位编译系统下，long和int占的空间是相同的

  float:变量类型，float是单精度的浮点型

  double:双精度浮点数;double是类型，如：int是整型 long是长整型 char是字符类型 float是浮点型等   
          double比float高一级
  boolean:boolean是java关键字，表示就像c和c++中的bool一样。但是java中的boolean只能是true和 
          false， 而不能像c和c++中的可以bool flag =1；这样赋值。而只能像boolean b = true或者           boolean b = false；这样赋值。

  char:char是Java中的保留字，表示一种数据类型。与别的语言不同的是，char在Java中是16位的，因为  
        Java用的是Unicode编码。不过8位的ASCII码包含在Unicode编码中，其值对应于0~127。

  private:在C++和java中都是变量修饰符，在类中当一个变量或方法用private修饰后，只有本类的方法和 
          变量才能调用。
  protected:protected为访问控制符，意思为受保护的，其开放程度仅次于public。
           1、protected访问控制符能被用于方法和成员变量。
           2、声明为protected的方法和成员变量能被同一个包里的所有类所访问，就像默认修饰符         package一样。
  switch:witch关键字的中文意思是开关、转换的意思，switch语句在条件语句中特别适合做一组变量相等         的判断，在结构上比if语句要清晰很多。
  true:rue 即表示为真。因此while(true) 是一个无限循环，因为表达式的值一直为真。

  false:假的；false是常数. 一个表示与 true 相反的唯一布尔值。当自动数据类型指定将 false 转换为
        数字时，它变为0；将 false 转换为字符串时，它变为 "false" 。
  throw:throw是语句 
  throws:throws是声明
  try:try .... catch ....异常捕获、处理语句
  catch:try .... catch ....异常捕获、处理语句

七,
1.字面值
-10、100 整数型字面值
-3.14 浮点型字面值
-“abc”、“中国人” （半角）字符串型字面值
-‘A’ ‘人’ (一个字母）字符型字面值
-true、false 布尔型字面值
2.数据类型
【1】基本数据类型----四大类，八小种
【2】引用数据类型----类，字符串(“abc”)
#基本数据类型：
整数型：byte,short,int,long
浮点型：float,double
布尔型：bolean
字符型：char（‘a’）
#基本数据类型占用空间大小【字节】
----------------------------------------------
byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1
char 2
#字节（byte）
1 Byte=8 bit 【一字节=8个比特位】一个比特位表示一个二进制位
1KB=1024Byte
1MB=1024KB
1GB=1024MB
1TB=1024GB

 1TB=1024*1024*1024*1024*8 bit
# byte类型最大值：2的7次方-1，结果是：127（100000000）
  byte类型最小值：-128
  bate取值范围：{-128~127}可表示256个不同的数字
#字符编码（ASC11码）：起转换作用，对照表作用
  ‘a’--->97【01100001】
  ‘A’--->65
  ‘0’--->48
#后来出现了一种编码方式统一了全球所有的文字，容量较大
   unicode

3, *随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO制定的，这种编码方式支持西欧语言，向上兼容ASCII码，仍然不支持中文。这种编码方式是：ISO-8859-1，又被称为latin-1。
*随着计算机向亚洲发展，计算机开始支持中文、日文、韩文等国家文字，其中支持简体中文的编码方式：
GB2312 < GBK < GB18030（按内存大小）
*支持繁体中文：大五码
*后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：unicode编码。
具体实现：
- UTF-8
- UTF-16
- UTF-32
…
*Java语言采用的是哪一种编码方式呢？
-java语言源代码采用的是unicode编码方式，所以“标识符”可以用中文。
*现在实际开发中，一般使用UTF-8编码方式较多。【统一编码方式】
4,八种数据类型的取值范围
数据类型取值范围默认值
-------------------------------------------------------
byte -128~127 0

short -32768~32767 0
int -2147483648~2147483647 0
long 0
float 0.0
double 0.0
boolean true/false false
char 0~65535 \u0000
5.成员变量没有赋值，系统会默认赋值，赋值为0
局部变量不会
6.char
\n : 转义符
\t : 制表符
\’ ：普通的单引号
\ ：普通的双斜杠
\” ：普通的双引号
JAVA中自带的native3ascii.exe命令，可将文字改为unicode编码形式
7.关于java语言中的整数型
数据类型占用空间默认值取值范围

Byte 1 0 -128~127
Short 2 0 -32768~32767
Int 4 0 -2147483648~2147483647
Long 8 0L
1.java语言中的“整数型字面值”被默认当作int类型处理。要让这个“整数型字面值”被当作long类型处理的话，需要在“整数型字面值”后面添加i0/L,建议使用大写L。
2.java语言当中的整数型字面值有3种表达方式：
第一种方式：十进制【是一种缺省默认的的方式】常用
第二种方式：八进制【在编写八进制整数型字面值的时候需要以0开始】
第二种方式: 十六进制【在编写八进制整数型字面值的时候需要以0x始】
#容量向大容量转换叫做自动类型转换 eg:long x=456
Long x=2147483648L 【面试题范围超出int】
#容量向小容量转换叫做强制类型转换 eg：long x=100L
有时会损失精度 Int y=x 改为int y=(int) x
System.out.println(y)

Byte b=50；可以
Byte c=127://可以
Byte b1=128:编译报错
*SUN公司规定只要在byte范围内可以编译成功】【-128~127】
*一个整数字面值没有超过byte,short,char的取值范围，这个字面值可以直接赋值给byte,short,char类型的变量。

8.关于java语言当中的浮点型数据类型：
float 单精度【4个字节】
double双精度【8个字节，精度较高】

double精度太低【相对来说】，不适合做财务软件，SUN在基本类库准备了精确度较高的类型，只不过这种
这种类型是一种引用数据类型，不属于基本数据类型，—java.math.BigDecimal
SE类库字节码：C:\Program Files\Java\jre1.8.0_101\lib\rt.java
SE类库源码：C:\Program Files\Java\jdk1.8.0_101\src.zip

在java语言中，所有的浮点型字面值【3.0】，默认被当作double类型来处理，
要想该字面值当作float类型来处理，需要在字面值后面加F或f

9.关于java语言当中的布尔型数据类型
boolean只有两个值：true，false
实际开发非常重要，经常使用在逻辑运算和条件控制语句当中。
10.*关于基本数据类型之间的互相转换：转换规则
1、八种基本数据类型当中除布尔类型之外剩下的7种类型之间都可以互相转换。
2、小容量向大容量转换，称为自动类型转换，容量从小到大排序：
byte < short < int < long < float < double
char
注：任何浮点类型不管占用多少个字节，都比整数型容量大。
char和short可表示的种类数量相同，但是char可以取更大的正整数。
3、大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度，所以谨慎使用。
4、当整数字面值没有超出byte，short，char的取值范围，可以直接赋值给byte，short，char类型的变量。
5、byte，short，char混合运算的时候，各自先转换成int类型再做运算。
6、多种数据类型混合运算，先转换成容量最大的那种类型再做运算。
11.运算符

*关于java编程中运算符之：算术运算符
+ 求和
- 相减
* 乘积
/ 商
% 取余数【取模】

 ++   自加1
 --    自减1
注意：一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。没有必要去专门记忆运算符的优先级。
++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后，只要++运算符结束，该变量中的值一定会自加1。
      ++运算符出现在变量后，先做赋值运算，再对变量中保存的值进行自加1。
      ++运算符出现在变量前，先进行自加1运算，然后再进行赋值运算。



public class A{
public static void main(String[] args){
	int k=100;
    System.out.println(k++);//100  101
    System.out.println(k--);//101  100
	System.out.println(--k);//99         s= 99
	System.out.println(k++);//99         100
	System.out.println(k++);//100        101
	System.out.println(++k);//102        102
	System.out.println(--k);//101        101
	System.out.println(k--);//101        100


			
	F:\源码>javac A.java

	F:\源码>java A
	100
	101
	99
	99
	100
	102
	101
	101

*关系运算符：

>         大于     
>=        大于等于
<         小于
<=        小于等于
==        等于
!=         不等于
= 是赋值运算
== 是关系运算符

关系运算符的运算结果一定是布尔类型：false/true

关系运算符的运算原理：
       int a = 10;
       int b = 10;
       a>b比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较。
       a==b也是如此。

*逻辑运算符：

&      逻辑与【并且】（两边的算子都是true，结果才是true）
|      逻辑或【或者】（两边的算子只要有一个是true，结果就是true）
!      逻辑非（取反，!false就是true，!true就是false，这是一个单目运算符）
^      逻辑异或（两边的算子只要不一样，结果就是true） 

&&      短路与
||      短路或

1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
2、短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象。
3、短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象。

4、什么情况下发生短路现象呢？
  什么情况下发生短路或？
	*第一个表达式执行结果是true，会发生短路或。
  什么情况下发生短路与？
	*第一个表达式执行结果是false，会发生短路与。

5、什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？
  从某个角度来看，短路与更智能。由于后面的表达式可能不执行，所以执行效率较高。这种方式在实际的开发中使用较多。短路与比逻辑与使用的多，短路与更常用。
  但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的表达式不执行。

*赋值运算符：
赋值类运算符包括两种：
*基本的赋值运算符
=
*扩展的赋值运算符
+= 等同于：i = i + 5;
-=
*=
/=
%=
1、赋值类运算符的优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量。
2、注意以下代码：
byte i = 10;
i += 5; 等同于：i = (byte)( i + 5 );

int k = 10;
K += 5; 等同于：k = (int)( k + 5 );

long x = 10L;
int y = 20;
y += x;等同于：y = (int)( y + x );
3、重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎样进行追加或追减，最终该变量的数据类型还是byte类型。

*****关于java中的“+”运算符：
1、+运算符在java语言当中有两个作用：
* 加法运算，求和
* 字符串的连接运算
2、当“+”运算符两边的数据都是数字的话，一定是进行加法运算。
3、当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算。并且，连接运算之后的结果还是一个字符串类型。
数字 + 数字 ——> 数字【求和】
数字 + “字符串”——>“字符串”【字符串连接】
4、在一个表达式当中可以出现多个“+”，在没有添加小括号的前提下，遵循自左向右的顺序依次运算。

关于java中的三元运算符/三目运算符/条件运算符：
1、语法规则：
     布尔表达式？表达式1：表达式2
2、三元运算符的执行原理？
   当布尔表达式的结果是true的时候，选择表达式1作为整个表达式的执行结果
当布尔表达式的结果是false的时候，选择表达式2作为整个表达式的执行结果

***控制语句
关于java语言当中的if语句，属于选择结构，if语句又被称为分支语句/条件控制语句：
1、if语句的语法结构：四种编写方法
第一种：
if(布尔表达式){
java语句；
java语句；
java 语句
…
}
第二种：
if(布尔表达式){
java语句；
java语句；
…
}else{
java语句；
java语句；
…
}
第三种：
if(布尔表达式){
java语句；
java语句；
…
}else if(布尔表达式){
java语句；
java语句；
…
}else if(布尔表达式){
java语句；
java语句；
…
}…
第四种：
if(布尔表达式){
java语句；
java语句；
…
}else if(布尔表达式){
java语句；
java语句；
…
}else if(布尔表达式){
java语句；
java语句；
…
}else{
java语句；
java语句；
…
}

	2、重点：对于java中的if语句来说，只要又一个分支执行，整个if语句全部结束。
	3、注意：以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以100%保证会有分支执行。
	4、“所有的控制语句”都是可以嵌套使用的。只要合理嵌套就行。
	注意：嵌套使用的时候，代码格式要保证完美。【该缩进的时候必须缩进】
	5、if语句的分支中只有一条java语句的话，大括号可以省略不写。
		 if(true/false)   一条java语句；【这种方式不推荐使用，别人这么写能看懂就行】


     switch(int或String类型的字面值或变量){
     case int或String类型的字面值或变量：
     java语句;
	 ...
	 break;
	 case int或String类型的字面值或变量：
     java语句;
	 ...
	 break;
	 case int或String类型的字面值或变量：
     java语句;
	 ...
	 break;
  ...
  default：
    java语句;
	...
	 }

****1.switch语句的执行原理：
switch后面的小括号当中的“数据”和case后面的“数据”进行一一匹配，
匹配成功的分支执行，按照自上而下的顺序依次匹配。
2.匹配成功的分支执行，分支当中最后由“break;” 语句的话，整个switch
语句终止。
3.匹配成功的分支执行，分支当中没有“break；”语句的话，直接进入下一个
分支执行（不进行匹配），这种现象被称为case穿透现象。【提供break；语句
避免穿透】
4.所有分支都没有匹配成功，当有default语句的话，会执行default分支当中程序。
5.switch后面的和case后面的只可能是int或者String类型的数据，不能是探测其他类型
*当然byte，short，char也可以直接写到switch和case后面，因为他们可以进行自动
类型转换 byte，short，char可以自动转换成int类型。
6，case可以合并
int i=1;
switch(1){
case 1:case 2: case 3: case11:
System.out.println(“Test Code!”);
}

****break
1.break+";"
2.break使用在switch语句中，用来终止switch语句执行。
3.break;用在for、while、do…while循环语句当中，用来跳出循环。
4.默认情况下，break终止的是离他最近的循环语句；
****Method 方法
1.语法结构
[修饰符列表] 返回值类型方法名(形式参数列表){
方法体;
}
2.解释
1>可选项，不是必须的
2>目前统一写成：public static
3>方法的修饰符列表当中“有static关键字”的话，怎么调用这个方法？
-类名.方法名(实际参数列表);