Java学习的第一篇博客

最新推荐文章于 2024-10-06 20:29:51 发布

№613

最新推荐文章于 2024-10-06 20:29:51 发布

阅读量318

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_64970885/article/details/122885655

版权

一、Java基础语法

码代码的小白要努力学习！

1.注释

public class helloworld {
    public static void main(String[] args) {
        //单行注释
        //输出一个hello world
        System.out.println("hello world");

        //多行注释
        /*
        我是多行注释
        我是多行注释
         */

        //Javadoc：文档注释  /**
        /**
         * @author
         */
    }
}

2.标识符

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

所有的标识符都应该以字母（A-Z或者a-z）,美元符$,下划线（_）开始。

不能使用关键字作为变量名或者方法名！

public class demo1 {
    public static void main(String[] args) {
        //大小写十分敏感
        String Ahello = "ABCD";
        String ahello = "ABCD";
        String $hello = "ABCD";
        String _hello = "ABCD";
        String _1 = "ABCD";
    }
}

3.数据类型

Java的数据类型分为两大类：基本类型（primitive type）、引用类型(reference type)

public class demo2 {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int num1 = 10;  //最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;  //Long类型要在数字后面加一个L

        //小数：浮点数
        float num5 = 50.1f;  //float类型要在数字后面加一个f
        double num6 = 3.1415926;

        //字符
        char name = 'A';

        //布尔值:是非
        boolean flag = true;
        boolean flag1 = false;
    }
}

什么是字节？

位（bit）：是计算机内部数据存储的最小单位

字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示

1B = 8bit

1024B = 1KB 1024KB = 1M 1024M = 1G

扩展

public class demo3 {
    public static void main(String[] args) {
        //整数扩展： 进制

        int i = 10;
        int i2 = 010; //八进制0
        int i3 = 0x1f; //十六进制0x
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

        //===================
        //浮点数扩展   
        //BigDecimal  数学工具类
        // ===================
        //float   有限  离散  舍入误差  大约  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较

        float f = 0.1f;
        double d = 1.0 / 10;

        System.out.println(f == d);
        System.out.println(f);
        System.out.println(d);

        //===================
        //字符拓展
        // ===================
        char c1 = 'A';
        char c2 = '中';

        System.out.println(c1);
        System.out.println((int) c1);  //强制转换
        System.out.println(c2);
        System.out.println((int) c2);
        //所有的字符本质还是数字

        //转义字符
        //\t  制表符
        //\n  换行

        System.out.println("hello\nworld");

        System.out.println("===================");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb);

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);
        //对象  从内存分析

        //布尔值拓展
        boolean flag = true;
        if (flag == true) {        }  
        if (flag) {        }  
        //less is more!  代码要精简易读
    }
}

4.类型转换

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);

        int i1 = 128;
        double c = i1;

        System.out.println(i1);
        System.out.println(c);

        /*
        注意点:
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.在把高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出或者精度问题
         */

        //操作数比较大的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        System.out.println(money);
        int years = 20;
        int total = money * years; //-1474836480,计算溢出了

        long total2 = money * ((long)years);
        System.out.println(total2);
    }
}

5.变量

java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

基本变量的定义：

public class demo5 {
    public static void main(String[] args) {
        //int a = 1, b = 2, c = 3;  //程序的可读性
        int a = 1;
        int b = 2;
        char x = 'x';
        String name = "ABCD";
        double pi = 3.14;
    }
}

作用域

类变量、实例变量、局部变量

public class demo6 {
    //属性：变量
    //类变量 static
    static double salary = 2500;

    //实例变量：从属于对象，如果不自行初始化，会变成这个类型的默认值
    //布尔值：默认的是false    除了基本类型，其余默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {

        //局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //实例变量   变量类型 变量名字 = new demo6（）；
        demo6 demo6 = new demo6();
        System.out.println(demo6.age);
        System.out.println(demo6.name);

        //类变量 static
        System.out.println(salary);
    }

    //其他方法
    public void add(){

    }
}

常量：不会变化的值（final）

一般用大写字母表示

public class demo7 {
    //修饰符,不存在先后顺序
    final static double PI = 3.14;

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

6.基本运算

Java支持算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符、条件运算符、扩展赋值运算符。

算术运算符,赋值运算符

public class Demo01 {
    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 / (double)b);

        int c = 21;
        //取余，模运算
        System.out.println(c % a);
    }
}

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123L;
        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
    }
}

public class Demo03 {
    public static void main(String[] args) {
        //++  --  自增，自减  一元运算符
        int a = 3;
        int b = a++;  //执行完这行代码后，先给b赋值，再自增
        System.out.println(a);
        int c = ++a;  //执行这行代码前，先自增，再给c赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}

关系运算符

public class Demo04 {
    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);
    }
}

逻辑运算符

public class Demo05 {
    public static void main(String[] args) {
        //与    或    非
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:" + (a && b));  //逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a || b:" + (a || b));  //逻辑或运算：两个变量有一个为真，结果为true
        System.out.println("!(a && b):" + (!(a && b)));  //逻辑非运算：如果为真，则变为假

        //短路运算
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);
        System.out.println(d);
        System.out.println(c);
    }
}

位运算符

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A & B = 0000 1100 都为1才为1
        A | B = 0011 1101 都为0才为0
        A ^ B = 0011 0001 相同为0，不同为1
        ~B = 1111 0010 完全相反
         */

        /*
        <<  *2
        >>  /2

        0000 0000  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16
         */
        System.out.println(2<<3);
    }
}

扩展赋值运算符

public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a += b;  //a = a + b
        a -= b;  //a = a - b
        System.out.println(a);

        //字符串连接符  + ,String
        System.out.println(a + b);
        System.out.println("" + a + b);
        System.out.println(a + b +"" );
    }
}

三元运算符

public class Demo08 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x == true，则结果为y，否则为z

        int score = 80;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);
    }
}