Java学习笔记（一）基础（fundamental）

基础知识：

java编译运行过程:
java源文件(.java)，经过编译，编译为java字节码文件(.class)，然后通过JVM来加载.class并运行.class文件
不同系统有不同的JVM，但对.class是一样的
java可以实现跨平台
一次编程到处运行

JDK:java开发工具包
JRE:java运行环境
JVM:java虚拟机

JRE=JVM+java系统类库

JDK=JRE+编译、运行等开发环境
运行的最小环境为JRE
开发的最小环境为JDK

IDE:集成开发环境，eclipse是JAVA最主流的IDE
eclipse为IBM公司的，开源的

变量：

变量是一个代词，指代内存中的数据变量是可以改变的量---指代不同的数据

变量必须先声明，再使用
　　语法: 数据类型变量名;
　　　　int a;
　　可以一条语句声明多个同类型变量
　　　　eg: int a,b,c;
　　　　int a=1,b,c=2;

变量的命名:
　　规定:
　　1)只能包含字母、数字、_、$，并且不能以数字开头
　　2)严格区分大小写
　　3)不能使用关键字(java已经用了的字)
建议:
　　1)不建议中文命名变量
　　2)最好"见名知意"
　　3)驼峰命名法:第一个单词首字母小写，其余单词首字母大写
变量的初始化:
java语法规定:变量在使用前必须初始化
初始化两种方式:
　　1)声明同时初始化
　　　　int a=5;
　　2)先声明再初始化
　　　　int b;
　　　　b=8;

变量的使用:
　　1)必须与数据类型匹配
　　eg: int a=2.5; //错误，类型不匹配

数据类型：

int:
　　1)整型，占4个字节，范围-21个多亿到21个多亿
　　2)整数直接量(25,250,2500...)，默认为int类型
　　3)两个整数相除，结果为整数(无条件舍去小数位)

　　int型变量只占4字节
long:
　　1)长整型，占8个字节，范围特别大(足够用)
　　2)long型直接量，在数字后面加l或L
　　eg: long a = 35L;

　　int a=10000000000; //错误
　　long a = 10000000000; //错误
　　long a = 10000000000L;//正确

float:

　　1)单精度浮点型，占用4字节。

　　2)float型直接量直接在浮点数后加f或者F

double:

　　1)双精度浮点型，占8个字节。

　　2)浮点型直接量（1.1，1.0，……）默认为double

char:

　　1)字符型。占用一个字节

　　2) 赋值是用单引号（''）括起来

　　3) 字符型变量只接受一个字符。

　　eg： char c = 'a';

　　　　char c ='ab' //错误。

boolean：

　　1) 布尔型变量，属于int的子集。

　　2)只有两个值 true 和 false。

　　3)一切非0值代表true其余代表false。

各个类型之间的转换：变量 = （需要转换的类型）变量

　　eg int a = 10;

　　long l = (long)a;

逻辑运算符：

&&:两边都为真，则为真
||:有一边为真，都为真
!:非真则假，非假则真

Java中的HelloWorld：

public class HelloWorld {

	public static void main(String[] args) {
		System.out.println("Hello World");
	}

}

Java中main方法为程序的入口。

Java中输出语句为：System.out.println();

Java接收用户输入:

import java.util.Scanner; //1.导入Scanner包
public class HelloWorld {

	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in); //2.创建Scanner对象
		System.out.println("请输入你的年龄：");
		int age=scan.nextInt(); //3.等待用户输入一个int型变量。
		System.out.println("请输入你的身高：");
		double height = scan.nextDouble();//等待用户输入一个double变量
		
		boolean b1 = age>=18 && age<=50;//判断年龄是否在18-50之间。
		System.out.println(b1); //true
	}

接受用户输入主要分为3步：

　　1）import java.util.Scanner; //导入Scanner包

　　2）Scanner scan = new Scanner(System.in); //创建一个scanner对象。

　　3）int age=scan.nextInt(); //3等待用户输入。

运算符：

表格中的实例假设整数变量A的值为10，变量B的值为20：

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取模 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
--	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文）

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 查看  d++ 与 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

　　结果如下：

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

自增自减运算符

1、自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。

public class selfAddMinus{
    public static void main(String[] args){
        int a = 3;//定义一个变量；
        int b = ++a;//自增运算
        int c = 3;
        int d = --c;//自减运算
        System.out.println("进行自增运算后的值等于"+b);
        System.out.println("进行自减运算后的值等于"+d);
    }
}

运行结果为：

进行自增运算后的值等于4
进行自减运算后的值等于2

解析：

int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4
int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2

2、前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。

3、后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算实例：

实例

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

运行结果为：

自增运算符前缀运算后a=6，x=12
自增运算符后缀运算后b=6，y=10

关系运算符

下表为Java支持的关系运算符

表格中的实例整数变量A的值为10，变量B的值为20：

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假(非真)。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）非真。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：

A = 0011 1100
B = 0000 1101
-----------------
A&b = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13：

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
\|	如果相对应位都是0，则结果为0，否则为1	（A \| B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
\| \|	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A \| \| B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

赋值运算符

下面是Java语言支持的赋值运算符：

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A等价于C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
\| =	按位或赋值操作符	C \| = 2等价于C = C \| 2

三目运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

以上实例编译运行结果如下：

Value of b is : 30
Value of b is : 20

运算符优先级：

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	+ + - ！〜	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
关系	>> = << =	左到右
相等	== !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	\|	左到右
逻辑与	&&	左到右
逻辑或	\| \|	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = \| =	从右到左
逗号	，	左到右

分支结构：

if 语句的用语法如下：

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。

if...else语句

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

if...else if...else 语句

if 语句后面可以跟 elseif…else 语句，这种语句可以检测到多种可能的情况。

使用 if，else if，else 语句的时候，需要注意下面几点：

if 语句至多有 1 个 else 语句，else 语句在所有的 elseif 语句之后。
if 语句可以有若干个 elseif 语句，它们必须在 else 语句之前。
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

嵌套的 if…else 语句

嵌套的else只与最近的if相配对。

switch 语句

switch 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

语法

switch 语法格式如下：

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch 语句有如下规则：

switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串类型了，同时 case 标签必须为字符串常量或字面量。
switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
switch 语句可以包含一个 default 分支，该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

循环语句：

循环三要素:
1.循环变量初始化
2.循环条件(以循环变量为条件)
3.循环变量的改变(向着循环结束变)
循环变量:在循环过程中改变的那个量

int count=1; //跑的圈数---计数
count<=3 //条件------------跑
count++; //改变计数

count=1 true 跑
count=2 true 跑
count=3 true 跑
count=4 false

while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {
  //循环内容
}

do…while 循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
       //代码语句
}while(布尔表达式);

　　注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

for循环

虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

关于 for 循环有以下几点说明：

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式)
{
   //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("
");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

以上实例编译运行结果如下：

10,20,30,40,50,
James,Larry,Tom,Lacy,

break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

嵌套循环执行过程:
　　外层循环走一次，内层循环走所有次
建议:
　　循环层数越少越好
break:
　　只能跳出一层循环

数组：

1.数组可以装一组数，必须类型相同
2.数组按线性顺序，一个跟一个
3.数组也是一种数据类型
4.数组new之后，数组中的每个元素都有一个默认值
　　整数:0 浮点数:0.0 boolean:false

1)数组的定义:
　　int[] arr = new int[4]; //每个数都是0
2)数组的初始化

    int[] arr;  //声明数组
    arr = new int[4];  //初始化
    int[] arr = {1,5,8,3}; //只能声明同时初始化
    int[] arr = new int[]{1,5,8,3};

    int[] arr;
    arr = {1,5,8,3}; //错误

3)数组的访问:通过下标
下标从0开始

int[] arr = new int[4];
System.out.println(arr.length);//数组的长度4
arr[0] = 55;//给arr中的第1个数赋值为55
arr[4] = 99; //错误，数组越界，最大到3
System.out.println(arr[2]);//输出第3个数

遍历数组：

//遍历数组
int[] arr = {1,8,5,3};
for(int i=0;i<arr.length;i++){  //正序
    System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){  //倒序
       System.out.println(arr[i]);
}

int[] arr = {2,9,6,1,56,67,234,45,7657,234};
for(int i=0;i<arr.length;i++){
       System.out.println(arr[i]);
}

System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);

声明一个整型数组名为a，可以存储4个整数
　　int[] a = new int[4];
　　double[] s = new double[4];
　　String[] ns = new String[10];

数组的.length：

int[] arr = new int[5];
int i = arr.length; //5

数组

1)定义
　　数据类型[] 数组名 = new 数据类型[长度];
　　int[] arr = new int[5];
2)初始化
　　int[] arr = new int[3]; //默认值为0
　　int[] arr = {2,4,7};
　　int[] arr = new int[]{2,4,7};
3)访问:通过下标/索引
　　int len = arr.length; //长度
　　int num = arr[0]; //取第1个元素
　　int num = arr[arr.length-1];//取最后1个元素
　　arr[0] = 88; //赋值
　　System.out.println(arr[0]); //取值
4)复制
　　//从a的第1个元素开始
　　//复制到a1中，从第3个元素开始
　　//一共复制4个元素
　　System.arraycopy(a,0,a1,2,4);

　　//将a数组复制到b数组，b有6个元素
　　int[] b = Arrays.copyOf(a,6);
　　//给a数组扩容
　　a = Arrays.copyOf(a,a.length+1);
5)排序
　　Arrays.sort(arr); //升序

dataType[] arrayRefVar;   // 首选的方法
 
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

方法（函数，过程）：

方法：也叫函数、过程。

　　1）用于封装一段特定的逻辑功能。

　　2）尽可能独立。　　（一个方法只干一件事）

　　3）可以在程序中反复调用。

　　4）避免了代码的冗余。便于的代码的维护，有利于团队协作开发。

方法的定义：五要素

　　1）修饰词

　　2）返回值类型：

　　　　-可以有返回值也可以没有返回值。没有返回值写void，有返回值写特定的返回值类型。

　　　　-方法执行完后需要用到方法中的某个数据 ----需要返回值。

　　　　-通过return语句返回，return语句的作用在于结束方法并将数据返回。

　　3）方法名：见名知意。

　　4）参数列表：在调用时传递给方法，需要被方法处理的数据

　　　　-可以有参数，也可以无参数。 ----有参更灵活。

　　　　-在调用时，会将实际的参数值传递给方法的参数变量，必须保证传递参数的类型和个数符合方法的声明

　　5）方法体：放在一对大括号内。

修饰词返回值类型方法名(参数列表){
　　方法体
}

当方法需要返回结果时，设计特定返回值类型
不需要结果时，返回值类型为void

返回结果通过return关键字

//方法都是用于操作数据的
//如果所操作的数据比较固定---不需要参数
//若所操作的数据不固定-------需要参数

相关阅读:
Linux常用命令大全（非常全！！！）
Springboot项目与vue项目整合打包
 Spring Boot开启Druid数据库监控功能
 （八）CXF添加自定义拦截器
 （七）CXF添加拦截器
 （六）cxf处理一些Map等复杂类型
 （无）webservice执行过程深入理解
 （四）CXF处理JavaBean以及复合类型
 （三）使用CXF开发WebService客户端
 （二）使用CXF开发WebService服务器端接口
原文地址：https://www.cnblogs.com/zbuter/p/9163768.html