Java学习笔记(一)

时间:2022-03-14 11:47:31

基础知识:

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=6x=12 自增运算符后缀运算后b=6y=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("\n");
      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)方法体:放在一对大括号内。

Java学习笔记(一)

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

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


返回结果通过return关键字