javaSE初识

小王子玫瑰狐

已于 2024-09-10 20:51:20 修改

阅读量1k

点赞数 28

文章标签： java

于 2024-09-09 13:19:10 首次发布

本文链接：https://blog.csdn.net/2301_80174936/article/details/141587522

版权

前端：微信客户端网页三剑客【 HTML（素颜）、CSS（化妆）、JS（行为）】

后端：服务器帮你处理数据 Java C ++

测试测开：开发一些测试工具

运维：保证你的产品时时刻刻安全运行

Java的祖师爷--詹姆斯*高斯林

Java的特点：一次编译，到处运行跨平台的

HelloWorld

新建文本文档重命名为xxxx.java 在记事本中编辑，得到源代码
编译: cmd >后写：javac xxxx.java 得到字节码文件（以.class为后缀）
>java
得到运行结果

Java程序的运行：

Javac编译器（Javac.exe）将源文件（.java）编译为字节码文件
Java虚拟机运行.class文件

JDK JRE JVM 三者之间的关系？

JRE（java运行时环境）

JDK（Java开发工具包）= JRE+ 开发工具集（比如：javac） JRE = JVM + JavaSE标准类库

JVM（java虚拟机）

初识Java简单语句和语法

main方法示例

public class Test{
    public static void main(String[] args){
        System.out.println("Hello,Java");
}
}

public class JJJ{
     /**
     这是一个main方法
     @param args 这是参数
     */
    //       类名->尽量采用大驼峰的形式 eg.MaxNum 两个单词的首字母大写
    //public修饰的类名一定要和文件名是一样的，并且只有一个

    //main
    //下面这两行代码是：方法/函数
    //            返回值 方法名     形参
    public static void main(String[] args) {
    //public:访问修饰限定符-》private protected
    //static:关键字 表示静态的
        System.out.println("hello");//sout
        //打印 并且换行      字符串

    }
}
//一个java文件当中，只有一个和当前文件名一样的类！！
//class JJJ {} 这种写法是可以的

Java程序的结构：

源文件{类{方法{语句}}}

注释

//行注释      ctr+/

/**
 文档注释（帮你生成一个html文档）
 @author 作者
 @version 版本号
 */
//-d创建目录 
//-encoding UTF-8 -charset UTF-8 字符集修改为UTF-8

/*
块注释       快捷键 ctr+shift+/
 */

标识符

在程序中由用户给类名、方法名或者变量所取的名字

【硬性规则】

数字字母下划线美元符号$组成的

不能以数字开头，不能是关键字

【软性建议】

类名：每个单词的首字母大写（大驼峰）
方法名：首字母小写后面每个单词的首字母大写（小驼峰）
变量名：与方法名规则相同

数据类型与变量

基本数据类型四类整数浮点字符布尔八种

可移植性

字节型 1字节 / 短整型 2字节/ 整型 4字节 /长整型 8字节 / 单精度浮点数 4字节

双精度浮点数 8字节/ 字符型 2字节 / 布尔型无明确规定

整型和浮点型都是有符号的
单位 bit -8->byte-1024->kb mb gb tb pb 1024程序员节 k m g t p

字面常量

1．字符串常量

2．整形常量

3.浮点数常量

4．字符常量

5．布尔常量：只有两种true和false

6．空常量：null

变量

局部变量：定义在方法内部的变量叫做局部变量

变量都是有类型的，a的类型-》 a的数据类型【int类型】，占用的空间是4个字节

int a = 10;

左值右值

在Java中局部变量一定要赋值，否则编译不通过，局部变量在使用的时候，一定要赋值的

整型变量

以int为例

32个bit位，第一位是符号位（0 是正数 1是负数），剩下的31bit是数值位

0 111 1111 1111 1111 1111 1111 1111 1111 正数的最大值 2^31 -1

1 000 0000 0000 0000 0000 0000 0000 0000 负数的最小值 - 2^31

public class F {
    public static void main(String[] args) {
        long b = 10L;   //长整型  -2^63  -   （2^63)-1   在后面加一个L表示长整型
        System.out.println(Long.MAX_VALUE);//首字母大写对应的是包装类型
        System.out.println(Long.MIN_VALUE);

        short sh = 10;//短整型 2个字节 -2^15  - (2^15)-1
        System.out.println(Short.MAX_VALUE);//32767
        System.out.println(Short.MIN_VALUE);//-32768

        byte b1 = 10;//字节型  1个字节 -2^7 - (2^7)-1    -128 - 127
//注意范围
    }
}

浮点型变量

public class F {
    public static void main(String[] args) {
        double d = 12.5;//8个字节
        System.out.println(d);
        System.out.println(Double.MAX_VALUE);
        int a = 1;
        int b = 2;
        System.out.println(a / b);// 执行结果 0
        //从数学上来说，就是0.5  但是此时在程序上说不能够保存小数

        //精确到小数点后xxxx位
        double num = 1.1;
        System.out.println(num * num);

        float f = 12.5f;//后加f表示单精度的浮点类型   4个字节
        System.out.println(f);

    }
}

在java中，小数点后不加f，认为是double类型的数据

字符型变量

public class F {
    public static void main(String[] args) {
        //没有负数的
       char ch = 'A';//2个字节，这个是和C有区别的      0 - 2^16 -1
        System.out.println(ch);
        char ch2 = '高';//一个汉字是两个字节
        // 计算机中字符的本质上是一个整数
        // 在C语言中使用ASCII表示字符，而Java中使用Unicode表示字符。
        // 因此一个字符占用两个字节，表示字符的种类更多，包括中文
        //char的包装类型为 Character
    }
}

char ch = '呵'; 
System.out.println(ch);

执行 javac 的时候可能出现以下错误 :

Test.java:3: 错误: 未结束的字符文字

char ch = '鍛?';

此时我们在执行 javac 时加上 -encoding UTF-8 选项即可

布尔型变量

public class F {
    public static void main(String[] args) {
        //0是假，非0是真  但是Java中 真假 只有true 和 false
      boolean flg = true;
        System.out.println(flg);
        //不能和任何类型进行转换！
        //没有明确规定占几个字节
        //包装类型为 Boolean
    }
}

总结：

都有包装类型除 int 是Integer char是Character

都是首字母大写

类型转换

public class F {
    public static void main(String[] args) {
       int a = 10;
       long b = 100L;
       //a = b;//不可以赋值8个给4个字节
        a = (int)b;//强制类型转换！！！
        //我对此次强制负责 ，如果丢失数据认可！
        b = a;//隐式类型转换
        //代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
        //数据范围小的转为数据范围大的时会自动进行


        //byte c = 256;  报错
        byte c2 = 127;
        //Java当中 对于字面值的直接赋值 是允许的，前提是没有超过表示范围
        //但是当超过表示范围之后，就会检查

    }
}

注意事项：
1．不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换成范围较大的类型

2．如果需要把范围大的类型赋值给范围小的，需要强制类型转换，但是可能精度丢失

3．将一个字面值常量进行赋值的时候，Java会自动针对数字范围进行检查

4．强制类型转换不一定能成功，不相干的类型不能互相转换

类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的
1．不同类型的数据混合运算，范围小的会提升成范围大的．
2．对于short, byte这种比4个字节小的类型，会先提升成4个字节的int，再运算．

public class F {
    public static void main(String[] args) {
       int a = 10;
       long b = 20;
       int c = (int)(a+b);//等号的右边是long类型 左边是int类型  会丢失数据
       long d = a+b;//正确的写法

        //小于4个字节的内容，会提升为int参与运算
        byte b1 = 125;
        byte b2 = 123;
        byte b3 = (byte)(b1+b2);//结果为-8
        System.out.println(b3);

        int b4 = b1  + b2;
        System.out.println(b4);//正确写法



    }
}

字符串类型

public class F {
    public static void main(String[] args) {
      //在c语言当中   有没有字符串这种数据类型？？无
        /*char *p = "123";
        char[] arr = "fdfa";
         */
        String str = "hello";//双引号当中 包含若干的字符
        //属于数据结构中的引用数据类型  无包装类
        //包装类只是 针对基本数据类型 对应的类类型
        System.out.println(str);

        //整数转字符串
        int a = 100;
        //调用String这个类型的方法
        String s1 = String.valueOf(a);
        System.out.println(s1);

        String s2 = a + "hellox";//此时这个加号就是拼接的意思
        System.out.println(s2);

        //注意区别
        String s3 = 10 + 20 + "x";//结果为30x
        String s4 = "x" + 10 +20;//结果为x1020

        //字符串转整数
        String str3 = "10009";
        //调用Integer 的方法 来实现转换
        int ret = Integer.valueOf(str3);
        System.out.println( ret +1);

        int ret2 = Integer.parseInt(str3);
        System.out.println( ret2 +1);




    }
}

总结：Java在此处与C语言的区别

1.字节大小

2.有包装类的概念

3.有字符串类型

4.特殊的类型需要注意布尔类型 char

运算符

算术运算符

public class F {
    public static void main(String[] args) {
        System.out.println(5/2);//2
        System.out.println((float)5/2);//2.5
        System.out.println(5/(float)2);//2.5
        System.out.println((float)(5/2));//2.0
        //被除数与除数有一个浮点数，结果为浮点数
        //除数不能为0   否则会算术异常

        //取余
        System.out.println(10%3);//1
        //负数求余数
        System.out.println(10%-3);//1      -3🐟1
        System.out.println(-10%3);//-1     -3🐟-1
        System.out.println(-10%-3);//-1     3🐟-1
        //不仅仅可以对 int 取余, 也能对 double 来取余
        System.out.println(11.5 % 2);//1.5

        int a = 10;
        a+=10;//a = a+10;
        System.out.println(a);
        //特殊情况
        long d = 100;
        int c = 9;
        //c = c+d;报错
        c +=d;//c = (int)(c+d); 特点  这种运算符会帮我们进行类型转换
        System.out.println(c);

        //自增自减运算符
        int a = 10;
        //int b = ++a;//a = a+1  b = a  先加一再赋值
        int b = a++;//b = a  a = a+1
        System.out.println(a);
        System.out.println(b);


    }
}

关系运算符

public class F {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //最后的结果要么是true,要么是false
        System.out.println(a == b);//false
        System.out.println(a != b);//true
        System.out.println(a < b);
        System.out.println(a > b);
        System.out.println(a <= b);
        System.out.println(a >= b);

        //System.out.println(3< a <5); Java不能这样写 报错
    }
}

逻辑运算符

public class F {
    public static void main(String[] args) {
       //逻辑与  &&  布尔表达式1 && 布尔表达式2
        //一假全假，全真为真

        //逻辑或
        //布尔表达式1 || 布尔表达式2
        //一真全真

        // ！布尔表达式
        int a = 1;
        System.out.println(!(a==1));//false
        System.out.println(!(a==2));//true

    }
}

短路求值

对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式.

对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false 
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值.

  //这个不能表示短路【不建议这样写代码 这是一个特殊的例子】
        System.out.println(10 >20 & 10/0==0);//程序抛出异常
        System.out.println(10 < 20 | 10/0==0);//程序抛出异常

位运算符

快速求一个数字的二进制

5：0101 -> 1*2^0 +0*2^1 + 1*2^2 ---> 5

128

4✅

1✅

按位与 &：对应位上只要都是1 对应位的结果就是1

0101
0110 &
-----------
0100

按位或 |：对应位如果是1 对应位的结果就是1

0110
0011 |
----------
0111

按位取反 ~: 对应位是1就变成0 是0就变成1

0101
~
------
1010

按位异或 ^:一样的地方都是0，不一样的地方都是1

0110
0011 ^
-------
0101

1.0去异或任何数字其结果就是任何数字 0^n= n

2.n^n = 0

移位运算符

0000 1011 11 左移在右边补0

11 << 1 --> 0001 0110 -->22 11*2^1 ->

11 << 2 --> 0010 1100 - ->44 11*2^2 ->

0000 1011 右移在左边补符号位符号位是1补1 是0补0

11 >> 1 --> 0000 0101 -> 5 11/2^1

11 >> 2 -->0000 0010 ->2 11/2^2

>>> 无符号右移左边统一补0

-1：

1111 1111 >>> 1 ->0111 1111

<<< 没有的

条件运算符

表达式1 ？表达式 2 ：表达式3 结果为布尔表达式，不能单独存在

如果表达式1为真则执行表达式2 否则执行表达式3

小王子玫瑰狐

关注

28
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫