注释

注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序的.

程序在经过编译之后,生成的class文件,是不会保留注释的,所以注释不会影响程序的执行.

package cc.neeo;
/*
文档注释
 */
public class HelloWorld {
    /*
    多行注释
     */
    public static void main(String[] args) {
        // 单行注释
        System.out.println("hello world!");

    }
}

如果你的idea有安装通义灵码插件,也可以选中需要添加注释的代码,让通义灵码帮我们生成代码注释.

字面量

字面量,也叫做字面值：就是程序中能直接书写的数据，学这个知识的重点是：搞清楚Java程序中数据的书写格式。

常见字面量的分类:

常见数据	生活中的写法	Java程序中的写法	说明
整数	666, -888	666, -888	写法一致
小数	13.14, -5.21	13.14, -5.21	写法一致
字符	a,A,0,你	'a', 'A', '0', '你'	程序中必须使用单引号，有且仅能一个字符
字符串	张开	"张开"	程序中必须使用双引号，内容可有可无
布尔值	真,假	true,false	只有两个值：true：代表真，false：代表假
空值		值是：null	一个特殊的值，空值（后面会讲解作用，暂时不管）
特殊字符字面量		\n,\t

package cc.neeo;


public class HelloWorld {
    public static void main(String[] args) {
        literal();
    }
    // 输出各种类型的字面量，以展示Java中不同的数据表达方式
    public static void literal(){
        // 输出字符串字面量
        System.out.println("字符串");
        // 输出整数字面量
        System.out.println(123);
        // 输出浮点数字面量
        System.out.println(3.14);
        // 输出布尔字面量 true
        System.out.println(true);
        // 输出布尔字面量 false
        System.out.println(false);
        // 输出字符字面量 'a'
        System.out.println('a');
        // 输出包含中文字符的字面量 '中'
        System.out.println('中');
        // 输出换行符
        System.out.println('\n');
        // 输出制表符
        System.out.println('\t');
    }
}

变量

变量定义规范

int age = 18;
数据类型 变量名 = 数据;

数据类型: 限制变量的值必须是指定类型.
变量名:  首字母建议小写.
等号: 赋值(右边的赋值给左边的).
数据: 也可以称之为变量值,只要符合数据类型的值就行.

变量的好处

• 一次定义,可以各处引用.提高处理数据的灵活性和维护性.

变量的特点

• 变量值可以根据需求进行修改.

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        demo();
    }
    public static void demo(){
        int age = 18;
        age = 19;
        System.out.println(age);
        age  = age + 1;
        System.out.println(age);
    }
}

基础数据类型

Java中的基本数据类型分为4大类共8种类型.

• 整型:
  • bytes

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        demo();
    }
    public static void demo() {
        // 整型
        byte a = 1;
        // byte b = 128; // 越界了,报错
        short c = 2;
        int d = 3;
        // 注意,随便定义的整数字面量默认是int类型,444444444444这个字面量虽然没有超过long的范围,但超过了int的范围所谓飘红报错.
        // 如果想要定义为long类型,需要在字面量尾部加上L或者l后缀
        // long e = 444444444444;
        long e = 444444444444L;

        // 浮点型
        // 注意,随便定义的浮点字面量默认是double类型
        // 如果希望4.0定义为float类型,需要加上F或者f后缀
        float f = 4.0f;

        // 字符型
        char g = 'a';
        
        // 布尔类型
        boolean h = true;
    }
}

关键字和标识符

对于一个Java初学者来说，了解关键字和标识符是非常重要的，因为它们是构成程序的基本元素之一。

关键字

关键字是Java语言中具有特殊意义的预定义的标识符。这些词被语言本身保留用于特定的功能，比如控制结构、类型声明等。你不能用关键字作为变量名、类名或者方法名。以下是一些常见的Java关键字示例：

• public - 用于声明公共访问权限。
• class - 用于声明一个类。
• void - 指示一个方法不返回值。
• if - 用于条件判断。
• else - 用于条件判断的备选分支。
• for - 用于循环结构。
• int - 声明整型变量。
• return - 从方法返回值或结束方法执行。

java中大约有50个左右的关键字,我们没必要一下子都记住,因为当你起个变量名和关键字冲突了,会报错.这样慢慢就熟悉了.

标识符

标识符是你自己定义的名字，用来标识类、变量、方法、类型等。标识符可以由字母（a-z, A-Z）、数字（0-9）、下划线（_）和美元符号（$）组成，但是有一些规则需要遵守：

• 必须以字母、下划线或美元符号开头。
• 可以包含字母、数字、下划线或美元符号。
• 不能是Java的关键字。
• 应该有意义，并且描述变量或方法的作用。
• 推荐使用完整的单词而不是缩写。
• 对于变量名推荐使用小写字母开始，如果由多个单词组成，则后续单词首字母大写（camelCase风格）。
• 类名通常首字母大写，也遵循驼峰命名法。
• 常量名通常全部大写，单词之间用下划线分隔（如 MAX_VALUE）。

理解并正确使用关键字和标识符是编写可读性强、易于维护的Java代码的基础。

方法

“方法”是一种定义了一组指令集合的代码块，这些指令集合在一起完成特定的任务。方法可以看作是函数的一个特例，在不同的上下文中可能被称为过程、子程序等。

方法的定义

方法的完整定义格式:

修饰符  返回值类型  方法名(形参列表){
	方法体(实现具体的功能)
	return 返回值;
}

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        // 对于需要传参和接受返回值的方法的调用方式
        int result = max(3, 4);
        System.out.println(result);
        System.out.println("--------------");
        // 没有返回值的调用
        max2(3, 4);
        System.out.println("--------------");
        printHello();
        // 对于没有返回值的方法,不要写代码硬接.
        // void res = printHello();
    }
    // 有返回值的,需要指定返回值类型,并且在内部需要使用return进行返回
    public static int max(int a, int b) {
        int result = a > b ? a : b;
        return result;
    }
    // 没有返回值的方法,返回值类型一定要写void,这是java规定,也不需要写return
    public static void max2(int a, int b) {
        int result = a > b ? a : b;
        System.out.println(result);
        // return result;
    }
    // 无参数,也无返回值类型的方法的写法.
    // 打印两行hello的方法,需要参数也不需要返回值
    public static void printHello() {
        System.out.println("hello");
        System.out.println("hello");
    }
}

注意:

• 方法必须先定义再调用.
• 方法可以
• 如果有参数,调用时需要传递实参.
• 如果方法不需要返回值,可以不写return.
• 对于没有返回值的方法,不要写代码硬接.

方法重载

我们来了解一个新的知识点,叫做方法重载.

一个类中，出现多个同名的方法，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。

注意:方法重载只关心方法名称相同,但形参列表不同(类型不同,个数不同,顺序不同).

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        printVariable(100, 200);
        printVariable(100L, 200L);
        printVariable("s", 100, 200);

    }
    public static void printVariable(int x, int y) {
        System.out.println("x:" + x + ",y:" + y);
    }
    public static void printVariable(double x, double y) {
        System.out.println("x:" + x + ",y:" + y);
    }
    public static void printVariable(String x, int y, int z) {
        System.out.println("x:" + x + ",y:" + y + ",z:" + z);
    }
    // 注意下面这个方法就不是方法重载,而是定义重复的方法,因为它的形参和上面第一个方法重载的是同一个类型
    // public static void printVariable(int x1, int y1) {
    //     System.out.println();
    // }
}

方法重载的作用是什么?举个例子,如下代码示例.

下面类中有两个calculateArea方法，一个接受单个参数（半径），另一个接受两个参数（长度和宽度）。这使得用户可以根据形状的不同，调用相应的方法来计算面积。

另一个示例是根据传参的类型不同,来进行不同的输出.

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        // 第一个示例,计算面积
        calculateArea(8);
        calculateArea(8.0, 6.0);
        
        // 第二个示例,打印输出
        print("abc");
        print(200);
        print(true);

    }
    // 计算圆形面积
    public static void calculateArea(double radius) {
        System.out.println(Math.PI * radius * radius);
    }

    // 计算矩形面积
    public static void calculateArea(double length, double width) {
        System.out.println(length * width);
    }

     // 输出一个字符串
    public static void print(String text) {
        System.out.println(text);
    }

    // 输出一个整数
    public static void print(int number) {
        System.out.println(number);
    }

    // 输出一个布尔值
    public static void print(boolean flag) {
        System.out.println(flag ? "true" : "false");
    }
}

方法重载的好处

• 代码复用：通过重载，可以复用方法名，减少代码重复。
• 提高代码可读性：使用相同的方法名可以表明这些方法执行的是相似的操作。
• 简化调用：调用者可以根据需要传递的参数类型轻松地选择合适的方法版本。

注意事项

• 尽管方法重载可以带来便利，但也需要注意以下几点：
• 方法重载依赖于参数列表的不同，因此仅仅返回类型不同不足以构成方法重载。
• 果参数列表完全相同，即使参数名称不同，也不能构成方法重载。
• 在设计方法时应考虑到方法签名的独特性，避免造成混淆。

通过合理使用方法重载，可以使代码更清晰、更易于管理和扩展。

return的扩展说明

方法在执行过程中,只要执行到return语句,就会立即结束方法的执行.无论这个方法有无返回值.

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        calculateDivide(10, 22);
        calculateDivide2(10, 22);
    }
    public static float calculateDivide(int a, int b) {
        if (b == 0) {
            System.out.println("除数不能为0");
            return -1;  // 方法中遇到return,方法就结束了
        }
        System.out.println(a / b);
        return a / b;
    }

    public static void calculateDivide2(int a, int b) {
        return;  // 方法中遇到return,方法就结束了
    }
}

类型转换

自动类型转换

类型范围小的变量值,可以直接赋值给类型范围大的变量,比如byte类型的变量,就可以赋值给int类型,当然也能赋值给double类型.

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        byte a = 10;
        demo1(a);
        demo2(a);
    }
    public static void demo1(int b) {
        
        System.out.println(b);
    }

    public static void demo2(double c) {
        
        System.out.println(c);
    }
}

自动类型转换在计算机中的原理.

java中,byte类型的变量a,会在内存中开辟一块空间,空间大小是1个字节也就是8位.

# 12的2进制表示形式
00001100

定义一个变量b,内存中也会开辟一块内存空间,大小是32位,4个字节.

在byte类型的12转为int类型时,发现是空间是存的下的.

# byte类型的12转为int类型之后的内存存储表示
00000000 00000000 00000000 00001100

上面的过程反过来就是范围大的转为范围小的类型,叫做强制类型转换,内部转换过程也是这样的,但是要有风险,比如存不下的情况,需要我们自行承担责任.

强制类型转换

类型范围大的变量,不可以直接赋值给类型范围小的变量,会报错,如果有需求,那么需要强制类型转换过去.

但要注意的是,强制转换时,可能会出现"存不下"的情况,最终导致数据溢出(丢失).这种后果需要我们自行承担.

对于浮点型强制转整型,会丢失小数部分,保留整数部分.

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        int a = 20;
        byte b = (byte) a;

        int c = 1500;
        byte d = (byte) c;

        double e = 13.14;
        int f = (int) e;
        
        System.out.println(b);  // 20, 能存下,没有溢出,强转成功
        System.out.println(d); // -36, 强转时发现存不下,发生了数据溢出
        System.out.println(f); // 13, 小数转整数,直接去掉小数部分
    }
}

表达式的自动类型提升

在表达式中，小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算。

package cc.neeo;
/*
byte,short,char --> int --> long -- float --> double
*/
public class HelloWorld {
    public static void main(String[] args) {
        byte a = 20;
        int b = 20;
        double c = 20;
        print(a, b, c);
        
    }
    public static void print(byte x, int y, double z) {
        // 表达式的最终结果类型是由参与值的最高类型决定的
        // 所以,在运算时，x,y,z都提升为double再进行统一运算
        // 这样保证了运算的精度
        System.out.println(x + y + z);
    }
}

注意,表达式的最终结果类型由表达式中的最高类型决定,就跟上例一样,最终的输出结果类型是double类型.

另外,在表达式中，byte、short、char是直接转换成int类型参与运算的.

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        byte a = 20;
        short  b = 20;
        char c = 'a';
        print(a, b, c);

    }
    public static void print(byte x, short y, char z) {
        // 这个示例中，x, y, z 都会被提升为 int 类型,那么字符a在ASCII码表中的
        // 顺序为97，所以加上20再加20, 得到137
        System.out.println(x + y + z);  // 137
    }
}

还有在定义返回值时,也要注意:

package cc.neeo;

public class HelloWorld {
    public static void main(String[] args) {
        byte a = 100;
        byte b = 100;
        byte c = 100;
        // print1(a, b, c);
        print2(a, b, c);

    }
    // 在下面方法的返回值的类型选择上,你可以选择byte类型,但是,如果3个值相加结果大于127,
    // 那么,在返回的时候,Java会自动将int类型转换为byte类型,导致结果溢出
    // public static byte print1(byte x, byte y, byte z) {
    //     System.out.println(x + y + z);  // 137
    //     return x + y + z;
    // }
    // 所以,这里我们选择返回int类型,这样,在相加的时候,总和再大,int类型都能表示
    public static int print2(byte x, byte y, byte z) {
        System.out.println(x + y + z);  // 137
        return x + y + z;
    }
}

输入输出

将程序的数据或者结果展示到:控制台,文件中,客户端等等,都可以认为是输出.

基础部分只关注将结果输出到控制台.

而输入则是程序读取用户的键盘输入,从文件中读取,数据库,网络传输等等,都是输入,此时也只关注用户的键盘输入部分.

java官方写好了Scanner程序来供我们获取用户的键盘输入.