JavaSE(基础)

最新推荐文章于 2023-04-15 17:59:54 发布

Hello一車一乗

最新推荐文章于 2023-04-15 17:59:54 发布

阅读量77

点赞数 1

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_44267967/article/details/115387347

版权

笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Java基础

1.注释

注释是标注解释作用，书写注释是一个非常好的习惯。

Java中的注释有三种：

单行注释(//)，多行注释(/*+Ent, ctrl+shift+/)，文档注释（/**+Ent）。有趣的代码注释

//这是单行注释
 /*这是
   多行
   注释*/
/**文档注释，有功能
         * @Description Hello World
         * @Author LMC
         */

有趣的代码注释：

//                            _ooOoo_    
//                           o8888888o    
//                           88" . "88    
//                           (| -_- |)    
//                            O\ = /O    
//                        ____/`---'\____    
//                      .   ' \\| |// `.    
//                       / \\||| : |||// \    
//                     / _||||| -:- |||||- \    
//                       | | \\\ - /// | |    
//                     | \_| ''\---/'' | |    
//                      \ .-\__ `-` ___/-. /    
//                   ___`. .' /--.--\ `. . __    
//                ."" '< `.___\_<|>_/___.' >'"".    
//               | | : `- \`.;`\ _ /`;.`/ - ` : | |    
//                 \ \ `-. \_ __\ /__ _/ .-` / /    
//         ======`-.____`-.___\_____/___.-`____.-'======    
//                            `=---='    
//    
//         .............................................    
//                  佛祖保佑             永无BUG

标识符

Java所有组成的部分都需要名字，类名，变量名，方法名都被称为标识符。

所有标识符都以字母（A-z）、美元符号（$）、下划线（_）开始。

首字符之后可以是字母（A-z）、美元符号（$）、下划线（_）、数字的任何组合。

不能使用关键字作为变量名或方法名，标识符是大小写敏感的。

2.数据类型

强类型语言：要求变量的使用要符合规定，所有的变量都必须先定义后才能使用。

若类型语言：

Java的数据类型分为两大类：基本类型、引用类型。

基本类型：数值类型（7种）、Boolean类型（1种 True/False）

数值类型：整数类型（byte、short、int、long）、浮点类型（float、double）、字符类型（char）。注意：String是字符串。

变量是什么：就是可以变化的量。

引用类型：类、接口、数组

public class Demo1 {
    public static void main(String[] args) {
        //八大基本数据类型
        //整数
        byte num1=10;//对应一个类Byte(Ctrl+鼠标左查看源码)
        short num2=20;
        int num3=30;//最常用，对应一个类Integer
        long num4=40l;//long类型要在数字后面加l
        //小数：浮点数
        float num5=50.1F;//float类型要在数字前面加F
        double num6=1.23456879;
        //字符
        char name1='a';//只允许写一个
        //字符串，String不是关键字，类
        //String name2="abc刘";
        //布尔值：是非
        boolean flag1=true;
        boolean flag2=false;
    }
}

什么是字节

位(bit)：是计算机内部数据存储的最小单位，11001100是一个8为二进制数。

字节(byte)：是计算机中数据处理的基本单位，习惯上用B来表示。

1byte=8bit

字符：是指计算机中使用的字母、数字、字、和符号。

电脑的32位和64位

3.类型转换

由于Java是强类型语言，所以要进行有些运算的时候需要用到类型转换。运算中，不同类型的数据先转换为同一类型，然后进行运算，有强制类型转换、自动类型转换。

低------------------------------------------------------------------------->高

byte，short，char–> int–> long–> float–> double

public class Demo4 {
    public static void main(String[] args) {
        int i=128;
        byte b= (byte) i;//强制类型转换（高-->低）,内存溢出
        //强制转换 （类型）变量名 高---低
        //自动转换 低-->高
        System.out.println(i);
        System.out.println(b);
        /*
        注意点
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.在把高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出或者精度问题
         */
        System.out.println((int)23.7);
        char c='a';
        int d=c+1;
        System.out.println(d);
        System.out.println((char)d);
        //操作数较大的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money=10_0000_0000;
        int years=20;
        int total=money*years;//-1474836480,计算的时候溢出了
        System.out.println(total);
        long total2=money*years;//默认是int，转换之前已经存在问题了
        long total3=money*((long)years);
        System.out.println(total3);//可正常输出
    }
}

4.变量常量

变量

变量就是可以变化的量，一个变量代表一个空间。Java是一种强类型语言，每个变量都必须声明其类型。Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域。

变量的命名规范：

1.所有变量、类名、方法名要见名知意(name/age/salary)，

2.类成员变量首字母小写和驼峰原则（除了第一个单词外，后面的单词首字母大写，例如：lastName），

3.局部变量首字母小写和驼峰原则，常量大写字母和下划线（MAX_VALUE）,

4.类名首字母大写和驼峰原则（例如：Demo/User），

5.方法名首字母小写和驼峰原则（例如：run()/getName()）

变量的含义与生活中的例子：电脑的一个内存条相当于一个衣柜，内存条里的数据类型(int,char)相当于衣柜内部的衣服分类区域(裤子、鞋)，数据类型的int类型相当于衣柜里放裤子的部分，int类型的数据名a、b相当于衣柜放裤子位置里的牛仔裤、运动裤。

//数据类型变量名=值;例如：int a=10 裤子区域 a=长裤子

类变量

实例变量

局部变量

public class Demo5 {
    //1.类变量 static
    static double salary=2500;//静态 共享
    //属性：变量
    //2.实例变量：从属于对象;
    // 如果不进行初始化这个类型的初始值为0/0.0/false等,除了基本类型（8种），默认值都是null，空
    String name="tom";
    int age=18;
    //常量
    static final  double PI=3.1415926;//常量，不可改变
    public static void main(String[] args) {
        //3.局部变量，必须声明和初始化值
        int i=10;
        System.out.println(i);
        //变量类型 变量名字=new Demo5();
        Demo5 demo5=new Demo5();
        System.out.println(demo5.age);
        System.out.println(demo5.name);
        //类变量 static
        System.out.println(salary);
    }
}

常量

常量，初始化后不能再改变值，不会变动的值。可以理解为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值;常量一般使用大写

5.运算符

算数运算符：+，-，*，/，%，++，–
赋值运算符：=
关系运算符：>，<，>=，<=，==(Java里的等于是用两个=进行判断)，!=（返回的结果：正确，错误，布尔值）
逻辑运算符：&&，||，！
位运算符：&，|，^，~，>>，<<，>>>
条件运算符（三元运算）：a？b :c
扩展赋值运算符：+=，-=，*=，/=

优先级：

package operator;

public class Demo1 {
    public static void main(String[] args) {
       //算数运算符：+，-，*，/，% 二元运算符（两个数字）
        //Ctrl+D:复制当前行到下一行
        int a=10;
        int b=20;
        int c=21;
        int d=20;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        //需要强转，否则结果为小数，输出却为0
        System.out.println(a/(double)b);//强转
        System.out.println(c%d);//取余，模运算
    }
}

package operator;

public class Demo2 {
    public static void main(String[] args) {
        long a=123123123123123L;
        int b=123;
        short c=10;
        byte d=8;
        System.out.println(a+b+c+d);//long
        System.out.println(b+c+d);//int
        System.out.println(c+d);//int
        //cast:转换
        //byte、short、char用运算符运算过后自动转为int类型
    }
}
package operator;

public class Demo3 {
    public static void main(String[] args) {
        //关系运算符 返回的结果：正确，错误，布尔值
        int a=10;
        int b=20;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}
package operator;

public class Demo4 {
    public static void main(String[] args) {
        //算数运算符：++,-- 自增自减，一元运算符（一个数字）
        int a = 3;
        System.out.println(a);
        int b = a++;//执行完这行代码后,先把a的值赋给b，a的值再+1
        //a=a+1
        System.out.println(a);//输出4（3+1）
        System.out.println(b);//输出3
        //a=a+1
        int c = ++a;//执行完这行代码前，a先+1，然后a再给b赋值
        System.out.println(a);//输出5
        System.out.println(b);
        System.out.println(c);//输出5（c=a）
        //幂运算，借助工具类math中pow()的方法
        //Alter+Enter可以自动生成该对象的引用
        double pow = Math.pow(2, 3);//2^3
        System.out.println(pow);
    }
}
package operator;

public class Demo5 {
    public static void main(String[] args) {
        //与（and），或（or），非（取反）
        boolean a=true;
        boolean b=false;
        //逻辑运算：两个变量都为真，结果才为true
        System.out.println("a&&b:"+(a&&b));
        //逻辑运算：两个变量有一个为真，结果就为true、
        //两个变量都为假，结果才为假
        System.out.println("a||b:"+(a||b));
        //逻辑运算：如果是假则为真，如果是真则为假
        System.out.println("!(a&&b)："+!(a&&b));
        //短路运算 a&&b，a为假时，b就不再运算
        int c=5;
        boolean d=(c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}
package operator;

public class Demo6 {
    public static void main(String[] args) {
        /*位运算，与二进制有关，对个数两字中相同位置的数字进行运算
         A= 0011 1100
         B= 0000 1101
----------------------------------------------
        A&B 0000 1100 与
        A|B 0011 1101 或
        A^B 0011 0001 异
        ~B  1111 0010 取反
        <<左移相当于*2 ，>>右移相当于/2
        效率极高
        0000 0000 0
        0000 0001 1
        0000 0010 2
        0000 0100 4
        0000 1000 8
        0001 0000 16
        */
        //  2*8=16  2*2*2*2
        System.out.println(2<<3);//左移
    }
}
package operator;

public class Demo7 {
    public static void main(String[] args) {
        //扩展赋值运算符+=，-=
        int a=10;
        int b=20;
        a+=b;//a=a+b a=10+20
        System.out.println(a);
        a-=b;//a=a-b a=30-20
        System.out.println(a);

        //字符串连接符 +，String
        System.out.println("字符串"+a+b);//进行字符串拼接
        System.out.println(a+b+"字符串");//进行运算
    }
}

Hello一車一乗

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaSE(基础)

Java基础1.注释注释是标注解释作用，书写注释是一个非常好的习惯。Java中的注释有三种：单行注释(//)，多行注释(/*+Ent, ctrl+shift+/)，文档注释（/**+Ent）。有趣的代码注释//这是单行注释 /*这是多行注释*//**文档注释，有功能 * @Description Hello World * @Author LMC */有趣的代码注释：//
复制链接

扫一扫