java笔记

提供了下载查看pdf版(2021.3.25更新)的链接,希望能有帮助

认识java

java简介

Java是一个非常流行的编程语言,发明于1991年,是Sun公司(现在被Oracle公司收购了)。

Java的分类

  • java SE 标准版
    主要是java的核心和基础,主要用在桌面应用开发,本学期学习的重点
  • java EE 企业版
    主要是用来开发网站后台程序(后端),下学期学习的重点

J2ee

  • java ME 移动版
    已经被淘汰,针对nokia手机

java的特点

  • 简单
  • 健壮
  • 面向对象
  • 网络功能
  • 安全性
  • 跨平台

跨平台的演示图:

java的执行过程:

  • java源代码文件的扩展名:*.java
  • java源代码文件经过JVM(java虚拟机)编译,生成*.class文件

编写java的hello world

  • 编译器安装(jdk)
  • jdk8(jdk1.8)最流行,最稳定的版本
  • 9/10/11/12/15(最新的版本)
  • jdk配置:

    • 配置java_home
    • 添加path

第一个java程序

笔记的代码输出结果基于Ubuntu 20.04(wsl2)

openjdk version "1.8.0_282"

  • 编写A.java文件
public class A{
    public static void main(String[] args){
        System.out.println("hello java!");
    }
}
  • 编译A.java文件javac A.java
  • 执行java A

注意1

A.java:
public class B{
    public static void main(String[] args){
        System.out.println("hello java!");
    }
}
$javac A.java:
A.java:1: error: class B is public, should be declared in a file named B.java
public class B{
       ^
1 error

注意:文件名和公共类的类名必须一样

注意2

A.java:
Public class B{
    public static void main(String[] args){
        System.out.println("hello java!");
    }
}
$javac A.java:
A.java:1: error: class, interface, or enum expected
Public class A{
^
1 error

注意:

  • java区分大小写
  • public是关键字,是不能修改的。

注意3

A.java:
public class B{
    public static void main(String[] args){
        System.out.println("hello java!")
    }
}
$javac A.java:
A.java:3: error: ';' expected
        System.out.println("hello java!")
                                         ^
1 error

注意:

  • java每一条语句必须以分号";"结尾
  • java中所使用的标点符号都是英文 ,;.()[]{}:

注意4

A.java
public class A{
    public static void main(String[] args){
        //这是一条不会被执行的语句
        /*
        这是
        多行
        注释
        */
            System.out.println("hello java!");
    }
}

注意:

  • 单行注释 //
  • 多行注释 /*注释内容*/
  • 注释的作用:

    • 解释程序代码
    • 不会被执行

问题:打印下面的图案

Test1.java
public class Test1{
    public static void main(String[] args){
            System.out.println("##########");
            System.out.println("##########");
            System.out.println("##########");
            System.out.println("##########");
    }
}
Test2.java
public class Test2{
    public static void main(String[] args){
            System.out.println("##########\n##########\n##########\n##########");
    }
}

java中的标识符与关键字

标识符的作用

给变量、方法、类起名字

标识符的要求

标识符由大小写字母,数字,下划线和美元符号($)组成,但不能以数字开头

大小写敏感

不能与java语言关键字重名

不能和java类库的类重名

不能由空格、@、#、+、-、/等符号

长度无限制

建议使用有意义的名称

不要使用true或false

public class Test3{    public static void main(String[] args){
            int a3 = 19;//合法
            int 3a = 29;//不合法
            int a# = 18;//不合法 不能使用除大小写字母,数字,下划线和美元符号($)以外的符号
            int 价格 = 100;// 合法,可以用中文,但不建议
            int class = 1903;//不合法,不能使用关键字作为变量名
            int Class = 1907;//合法
            int $x = 20;//合法
    }
}

关键字

有特殊含义、固定不变的单词,都是小写

数据类型:byte、short、int、long、char、float、double、boolean
包引入和包声明:import、package
类和接口的声明:class、extends、implement、interface
流程控制:if、else、switch、case、break、default、while、for 、do、continue、return
异常处理:try、catch、finally、throw、throws
修饰符:abstract、final、private、protected、public、static、synchronized
其他:new、instanceof、this、super、void、enum

变量和常量

变量:可变

常量:固定不变

变量

变量声明

  • 语法: 数据类型 变量名;
  • 举例:int a;

变量的定义与初始化

  • 初始化:给变量赋值

变量名称 = 值;

a=16;

  • 变量的定义:同时声明一个变量并且给它赋值

数据类型 变量名称 = 值;

int a = 16;

注意:

A.java
public class A{
    public static void main(String[] args){
        int a;
        System.out.println(a);
    }
}
$javac A.java:
A.java:4: error: variable a might not have been initialized
        System.out.println(a);
                           ^
1 error

a未赋值,报错

在使用一个变量之前必须先定义

数据类型

数据类型:确定变量所占用的内存空间大小,也可以确定变量所能够做的操作。

基本数据类型:byte boolean char short int long float double

引用数据类型:数组,类,接口

java数据类型分为基础类型(简单类型)和引用类型

| 数据类型 | 关键字 | 在内存中占用 的位数 | 取值范围 | 成员默认值 |
| - | - | - | - | - |
| 字节型 | byte | 8 | -128~127 | (byte)0 |
| 短整型 | short | 16 | -32768~32767 | (short)0 |
| 整型 | int | 32 | -2的31次方~2的次方31-1 | 0 |
| 长整型 | long | 64 | -263~263-1 | 0L |
| 字符型 | char | 16 | 0~65535 | ‘u0000’ |
| 单精度浮点型 | float | 32 | 1位符号,8位指数,23位尾数 | 0.0F |
| 双精度浮点型 | double | 64 | 1位符号,11位指数,52位尾数 | 0.0D |
| 布尔型 | boolean | 1 | true,false | false |

注意:计算机内部使用二进制数据,整型数据采用补码

public class test{
    public static void main(String[] args){
        byte  a = 128;
        System.out.println(a);
    }
}
$javac:
test.java:3: error: incompatible types: possible lossy conversion from int to byte
        byte  a = 128;
                  ^
1 error

注意:

  • 在定义变量或给变量赋值时要注意变量的数据类型和数值大小匹配
public class test{
    public static void main(String[] args){
        char  a = '中文';
        System.out.println(a);
    }
}
$javac test.java
test.java:3: error: unclosed character literal
char  a = '中文';
^
test.java:3: error: unclosed character literal
char  a = '中文';
^
test.java:3: error: not a statement
char  a = '中文';
^
3 errors
public class test{
    public static void main(String[] args){
        char  a = "中";
        System.out.println(a);
    }
}
$javac test.java
test.java:3: error: incompatible types: String cannot be converted to char
        char  a = "中";
                  ^
1 error

注意:

  • 在java中char类型占用2B空间,所以它能保存中文(一个),而且要注意,char类型要用英文单引号
public class test{
    public static void main(String[] args){
        float a = 3.14;
        System.out.println(a);
    }
}
$javac test.java
test.java:3: error: incompatible types: possible lossy conversion from double to float
        float a = 3.14;
                  ^
1 error

注意:

  • java语言中,所有的浮点数都是double类型
  • 若表示浮点数float则需要在数据后面添加f或F 例如: float a = 3.14f;
public class test{
    public static void main(String[] args){
        long a = 120;
        System.out.println(a);
    }
}
//不报错

注意:

将内存占用小的数据类型赋值给内存大的不会报错,但是会浪费空间;

可以在数据类型后面添加l或L表示long类型:long a = 120L

long

public class test{
    public static void main(String[] args){
        boolean a = true;//不会报错
        boolean b = false;//不会报错
        boolean c = 1;//会报错
        System.out.println(a);
    }
}
$javac test.java
test.java:5: error: incompatible types: int cannot be converted to boolean
        boolean c = 1;
                    ^
1 error

常量

字面常量:

  • 12 3.14 true 'h' -129

符号常量:

  • final 数据类型 变量名称 = 值;
public class test{
    public static void main(String[] args){
        final int a = 123;
        a = 127;
        System.out.println(a);
    }
}
$javac test.java
test.java:4: error: cannot assign a value to final variable a
        a = 127;
        ^
1 error

注意:不能给常量重新赋值

public class test{
    public static void main(String[] args){
        final int b;
        b = 129;
        System.out.println(b);
    }
}

注意:不会报错, 第一次赋值不会报错

public class test{
    public static void main(String[] args){
        //final int a = 123;
        //a = 127;
        final int b;
        b = 129;
        b = 130;
        System.out.println(b);
    }
}
$javac test.java
test.java:7: error: variable b might already have been assigned
        b = 130;
        ^
1 error

注意:会报错,不能给常量重新赋值

public class test{
    public static void main(String[] args){
        final int b;
        b = 129;
        b = 129;
        System.out.println(b);
    }
}
$javac test.java
test.java:7: error: variable b might already have been assigned
        b = 129;
        ^
1 error

注意:会报错,不能给常量重新赋值

表达式与运算符

表达式

  • 表达式:就是常量、变量、运算符的组合;

运算符

  • 运算符的作用:指明对操作数的运算方式。
  • 按操作数的个数分为:

    • 单目运算符(-a)
    • 双目运算符(a+b)
    • 三目运算符(a>b?a:b)
  • 按功能分类

    • 算数运算符 +,―,*,/,%,++,――
    • 关系运算符 >,<,>=,<=,==,!=
    • 逻辑运算符 !,&&,||,&,|
    • 赋值运算符 =,+=,―=,*=,/=等
    • 位运算符
    • 条件运算符 ?:
    • 其他 · , [] ,instanceof, () 等

算数运算符

+ - * / % ++ --

  • +表示做算数加法或字符串拼接
public class test{
        public static void main(String[] args){
                int a = 2;
                double  b = 3;
                int c = a+b ;
                System.out.println(c);
        }
}
$javac test.java
test.java:5: error: incompatible types: possible lossy conversion from double to int
                int c = a+b ;
                         ^
1 error

注意:执行任何运算首先统一数据类型,需要类型转换

类型转换:

  • 自动类型转换:小的数据类型自动转换为大的数据类型。int + duble --->double + double
  • 强制类型转换

修改方法:

//方法1
public class test{
        public static void main(String[] args){
                int a = 2;
                double  b = 3;
                double c = a+b ;//int 改为 double
                System.out.println(c);
        }
}
//结果:5.0
//方法2
public class test{
        public static void main(String[] args){
                int a = 2;
                double  b = 3;
                int c = int(a+b);//强制类型转换
                System.out.println(c);
        }
}
//结果:5

强制类型转换的语法:(目标数据类型)需要转换的值

  • *表示算数乘法 要实现y=2x+1表达式为y=2*x + 1
  • /表示算数除法,(注意不要写成反斜杠\)
public class test{
        public static void main(String[] args){
                int a = 5;
                int b = 2;
                int c = a/b;// 5/2 int/int=int
                System.out.println(c);
        }
}
//结果:2
public class test{
        public static void main(String[] args){
                int a = 5;
                int b = 2;
                double c = a/b;// int/int=int,然后进行类型转换为double,所以先得到结果2,再转换为2.0
                System.out.println(c);
        }
}
//结果:2.0
public class test{
        public static void main(String[] args){
                int a = 5;
                double b = 2;
                double c = a/b;// int/double=double/double 所以得结果2.5
                System.out.println(c);
        }
}
//结果:2.5

注意:

  • 两个int类型做除法,结果一定是int类型;而且计算结果很有可能是错的(与数学计算结果不一致)
  • 在除法中,只要有一个是小数类型,结果一定是小数类型,而且计算结果和数学计算一致
public class test{
        public static void main(String[] args){
                double c=5/2.;
                System.out.println(c);
        }
}
//结果:2.5
public class test{
        public static void main(String[] args){
                double c=5/.2;
                System.out.println(c);
        }
}
//结果:.2

注意:2.02.是一样的;0.2.2是一样的

  • %表示取余
public class test{
        public static void main(String[] args){
                int a=13%3;
                System.out.println(a);
        }
}
//结果:1
public class test{
        public static void main(String[] args){
                int a=-13%3;
                System.out.println(a);
        }
}
//结果:-1
public class test{
        public static void main(String[] args){
                int a=-13%-3;
                System.out.println(a);
        }
}
//结果:-1
public class test{
        public static void main(String[] args){
                double a=-13%3.2;
                System.out.println(a);
        }
}
//结果:-0.1999999999999993
  • ++自增一

public class test{
        public static void main(String[] args){
                int a = 7;
                a++;
                System.out.println(a);
        }
}
//结果:8
public class test{
        public static void main(String[] args){
                int a = 7;
                ++a;
                System.out.println(a);
        }
}
//结果:8

注意:单独使用时,++aa++无任何区别

public class test{
        public static void main(String[] args){
                int c = 7;
                int d = a++;
                System.out.println(c);//8
                System.out.println(d);//7
        }
}
//结果:8;7
public class test{
        public static void main(String[] args){
                int c = 7;
                int d = ++a;
                System.out.println(c);//8
                System.out.println(d);//8
        }
}
//结果:8;8

a++与++a:

  • --自减一(同上)

关系运算符

>,<,>=,<=,==,!=

结果一定是boolean,值为true或false

public class test{
        public static void main(String[] args){
                int a = 2;
                int b = 3;
                int c = a > b;
                System.out.println(c);
                //System.out.println(b);
        }
}
$javac test.java
test.java:5: error: incompatible types: boolean cannot be converted to int
                int c = a > b;
                          ^
1 error
  • 注意:关系运算符的结果是boolean类型,在Java中,boolean类型的值泵赋给int类型的变量
public class test{
        public static void main(String[] args){
                int a = 2;
                int b = 3;
                System.out.println(a>b);
        }
}
结果:false
public class test{
        public static void main(String[] args){
                int a = 3;
                int b = 3;
                boolean c = a >= b;
                System.out.println(c);
        }
}
结果:true
public class test{
        public static void main(String[] args){
                int a = 3;
                int b = 3;
                boolean c = a == b;
                System.out.println(c);
        }
}
结果:true

逻辑运算符

!,&&,||,&,|

  • and(与)&&
  • or(或)||
  • not(非)!
public class test{
        public static void main(String[] args){
                int a = 3;
                int b = 5;

                System.out.println(a && b);
        }
}
test.java:6: error: bad operand types for binary operator '&&'
                System.out.println(a && b);
                                     ^
  first type:  int
  second type: int
1 error
  • 注意:逻辑运算符的操作数必须是boolean类型,结果也是boolean
public class test{
        public static void main(String[] args){
                int a = 23;
                System.out.println(18 <= a <=35);
        }
}
test.java:4: error: bad operand types for binary operator '<='
                System.out.println(18 <= a <=35);
                                           ^
  first type:  boolean
  second type: int
1 error
public class test{
        public static void main(String[] args){
                int a = 23;
                System.out.println(18 <= a && a<=35);
        }
}

注意:逻辑运算符使用场合关系表达式 逻辑运算符 关系表达式

public class test{
        public static void main(String[] args){
                int a = 23;
                int b = 39;
                boolean c = a >b || a >50 && b <30;
                System.out.println(c);
        }
}
false

注意:&&的优先级高于||

public class test{
        public static void main(String[] args){
                int a = 23;
                boolean c = a> 10 || a++ <25;
                System.out.println(c);//true
                System.out.println(a);//23
        }
}

注意:短路效应

  • true||其他为了节省时间,java不会执行||右侧的其他部分
  • false && 其他为了节省时间,java不会执行&&右侧的其他部分
public class test{
        public static void main(String[] args){
                int a = 23;
                boolean c = a< 10|| a++ <25;
                System.out.println(c);//true
                System.out.println(a);//24
        }
}

赋值运算符

=,+=,―=,*=,/=

int a = 3;
a = a + 2;
a += 2;  //   a += 2  ---->    a = a + 2;
a *= 2;  //   a *= 2 ---->     a = a * 2;
a -= 2; //    a -= 2 ---->     a = a - 2;
a /= 2; //    a /= 2 ---->     a = a / 2;
public class test{
    public static void main(String[] args){
        int a = 3;
        int b = 2;
        int c = 4;
        a *= b+c;
        System.out.println(a);//18
    }
}
a = a * (b+c)

赋值运算符优先级最低

===的区别:

  • =是赋值运算符,把右边的值给左边的变量
  • ==是关系运算符,是比较左右两边的是否相等

===在js中存在

位运算符

| & ~ ^

public class test{
        public static void main(String[] args){
                int a = 2;
                int b = 3;
                int c = a | b;
                System.out.println(c);//3
        }
}
  • ||表示逻辑或运算符,连接两个boolean类型的值
  • |表示按位或运算符,连接两个数值型数据,首先把数值转换为二进制数据,然后按位进行或运算
  • &&表示逻辑与运算符,连接两个boolean类型的值
  • &表示按位与运算符,连接两个数值型数据,首先把数值转换为二进制数据,然后按位进行与运算
  • ^异或运算符,`true ^ true = false false ^ true = true false ^ false

加密/数据安全/计算机网络常用按位比较

在不借助中间变量的情况下,交换a和b

条件运算符

?:三目运算符条件?操作数1:操作数2

先判断条件,

true,返回操作数1

false,返回操作数2

int a = 2;
int b = 3:
int c = a>b?a:b;
/*if (a>b){
    c = a;
}else{
    c = b;
}*/

流程控制

三种基本控制结构:顺序,选择,循环

顺序结构

  • 1

选择结构

  • if语句
  • switch语句

if

if (条件表达式){
    要执行的语句
}


if(条件表达式){
    语句块1
}else{
    语句块2
}


if(条件表达式1){
    语句块1
}else if(条件表达式2){
    语句块2
}else if(条件表达式3){
…………
}else{
    语句块n
}
public class test{
    public static void main(String[] args){
        int age = 19; 
        if(age >= 18){
            // 下面的两行是一个语句块,是一个整体,会不会执行要看小括号里面的条件
            // 若条件成立,则执行下面的两行,否则不执行,直接跳出选择结果
            System.out.println("已经成人了!");
            System.out.println("你要为自己的行为负责哦");
        }
        System.out.println("程序结束"); // 不管上面的条件表达式的结果如何,这一行一定会执行
    }
}

switch

switch(表达式){
    case 值1 : 语句; break;
    case 值2: 语句; break;
    default : 语句;
}

循环结构

while

while循环

循环变量的定义
while(循环的条件){
    循环语句
    更新循环变量
}

do {
    循环语句;
} while(循环条件);

for(循环变量的定义; 循环条件; 更新循环变量){
    循环语句
}

System.out.println : 打印括号中的内容,然后换行
System.out.print : 打印括号中的内容,但不换行

do - while

与while相近(先执行一遍再判断)

for

for(定义循环变量;循环变量条件;循环变量的改变){
    循环语句;
}

待续

最后修改:2021 年 04 月 11 日 06 : 40 PM
如果觉得我的文章对你有用,请随意赞赏