java基础

吢禅

于 2024-08-12 15:18:06 发布

阅读量442

点赞数 9

文章标签： python 开发语言

本文链接：https://blog.csdn.net/y123916/article/details/141132568

版权

java基础

1.java第一课输出hello world

//创建了一个共有的public类
public class Hello {

      public static void main(String[] args){
    System.out.print("hello,world");
      }
}

2.表识符

表识符不能是数字开头

标识符不推荐用汉字因为汉字可能存在编译错误

标识符命名规范

Java标识符的命名规则（必须遵守）

只能由字母（大小写，26个英文字母）、数字（0~9）、下划线“_”和“$”符组成。
数字不可以开头。
不可以使用关键字和保留字，但是可以包含关键字和保留字。
Java中严格区分字母大小写。
对长度无要求。
标识符内不能含有空格。

.Java标识符的命名规范（约定俗成）

包名：当由多个单词组成时，所有单词都是小写。如aaa.bbb.ccc。类名、接口名：单词的首字母大写。如XxxYyyZzz。（大驼峰命名法）变量名、方法名：由多个单词组成时，第一个单词均小写，其它单词首字母大写。如xxxYyyZzz。（小驼峰命名法，简称驼峰法）常量名：所有字母均大写。且由多个单词组成时，单词之间用下划线“_”隔开。如XXX_YYY_ZZZ。

关键字

Java中的关键字（Keywords）是预定义的保留字，它们在Java语言中具有特殊的意义和用途。根据你提供的信息，这里列出了Java中的一些关键字，但没有提供每个关键字的具体用法。下面我将简要解释这些关键字的用途：

1.int - 用于声明整型变量。

2.public - 访问修饰符，表示类、方法或变量对所有其他类都是可见的。

3.this - 引用当前对象的实例。

4.finally - 与try-catch块一起使用，确保无论是否捕获异常，finally块中的代码都会执行。

5.boolean - 用于声明布尔值变量。

6.abstract - 用于声明抽象类或方法，表示不能直接实例化的类或不完整的方法实现。

7.continue - 跳过当前循环的剩余部分，直接进入下一次循环迭代。

8.float - 用于声明单精度浮点数变量。

9.long - 用于声明长整型变量。

10.short - 用于声明短整型变量。

11.throw - 手动抛出异常。

12.throws - 声明方法可能抛出的异常。

13.return - 从方法返回一个值或退出方法。

14.break - 跳出当前循环或switch语句。

15.for - 用于创建循环。

16.static - 表示类的静态成员，属于类而非类的实例。

17.new - 创建类的新实例。

18.interface - 用于声明接口，一种引用类型，可以包含方法声明和常量。

19.if - 条件语句，用于基于条件执行代码块。

20.goto - 是Java中的保留字，但未使用。

21.default - 在switch语句中表示默认情况。

22.byte - 用于声明字节型变量。

23.do - 用于创建循环，至少执行一次循环体。

24.case - 在switch语句中用于匹配特定的值。

25.strictfp - 用于声明类或方法，要求浮点计算的精确结果。

26.package - 用于声明类所在的包。

27.super - 引用父类的实例。

28.void - 表示方法没有返回值。

29.try - 与catch或finally一起使用，用于捕获和处理异常。

30.switch - 用于基于不同的情况执行不同的代码块。

31.else - 与if语句一起使用，表示条件不满足时执行的代码块。

32.catch - 用于捕获异常。

33.implements - 表示类实现了接口。

34.private - 访问修饰符，表示类、方法或变量只能被同一个类访问。

35.final - 表示变量的值不可更改，或方法不能被覆盖，或类不能被继承。

36.class - 用于声明类。

37.extends - 表示类或接口的继承。

38.volatile - 表示变量的值可以被多个线程同时修改。

39.while - 用于创建循环。

40.synchronized - 表示方法或代码块在同一时间只能被一个线程访问。

41.instanceof - 用于检查对象是否是特定类的实例或其子类的实例。

42.char - 用于声明字符型变量。

43.protected - 访问修饰符，表示类、方法或变量可以被同一个包内的类或所有子类访问。

44.import - 用于导入其他包中的类或接口。

45.transient - 表示变量不应该被序列化。

46.double - 用于声明双精度浮点数变量。

变量

变量的声明:语法数据类型变量名称 = 变量值

常量的声明: 语法 final 数据类型常量名称 = 常量值

1.\\ - 表示一个反斜杠字符（\）。

2.\' - 表示一个单引号字符（'），在字符字面量中使用。

3.\" - 表示一个双引号字符（"），在字符串字面量中使用。

4.\n - 表示换行符（New Line）。

5.\t - 表示水平制表符（Tab）。

6.\b - 表示退格符（Backspace）。

7.\r - 表示回车符（Carriage Return）。

8.\f - 表示换页符（Form Feed）。

9.\0 - 表示空字符（Null Character）。

10.\ddd - 表示一个八进制值的字符（其中 ddd 是1到3位的八进制数）。

11.\uxxxx - 表示一个Unicode字符（其中 xxxx 是4位的十六进制数）。

1.成员变量（也称为实例变量）：

成员变量是定义在类内部但在任何方法、构造函数或代码块外部的变量。
它们属于类的实例，每个对象都有自己的成员变量副本。
成员变量可以是静态的（属于类本身）或非静态的（属于类的实例）。
非静态成员变量可以访问类的其他成员变量和方法，包括静态成员变量。

2.静态变量：

静态变量是使用static关键字定义的变量。
它们属于类本身，而不是类的任何特定实例。
静态变量在类加载时被初始化，并且在程序运行期间只有一份副本。
静态变量可以通过类名直接访问，也可以通过类的实例访问。

3.局部变量：

局部变量是在方法、构造函数或代码块内部定义的变量。
它们只在定义它们的代码块内可见和可访问。
局部变量在使用前必须初始化，因为它们没有默认值。
局部变量在代码块执行完毕后不再存在。

4.参数变量：

参数变量是传递给方法或构造函数的变量。
它们在方法或构造函数的参数列表中定义。
参数变量在方法或构造函数内部作为局部变量使用。
参数变量可以是基本数据类型或引用类型，它们接收调用方法时传递的实际值或引用。

public class RunoobTest {
    // 成员变量
    private int instanceVar;
    // 静态变量
    private static int staticVar;

    public void method(int paramVar) {
        // 局部变量
        int localVar = 10;

        // 使用变量
        instanceVar = localVar;
        staticVar = paramVar;

        System.out.println("成员变量: " + instanceVar);
        System.out.println("静态变量: " + staticVar);
        System.out.println("参数变量: " + paramVar);
        System.out.println("局部变量: " + localVar);
    }

    public static void main(String[] args) {
        RunoobTest v = new RunoobTest();
        v.method(20);
    }
}

运算符

基本赋值运算符：

=：将右侧表达式的值赋给左侧的变量。

复合赋值运算符包括：

+=：将左侧变量与右侧表达式的值相加后赋值给左侧变量。
-=：从左侧变量中减去右侧表达式的值后赋值给左侧变量。
*=：将左侧变量与右侧表达式的值相乘后赋值给左侧变量。
/=：将左侧变量除以右侧表达式的值后赋值给左侧变量。
%=：计算左侧变量与右侧表达式的值的余数后赋值给左侧变量。
<<=：将左侧变量的值左移右侧表达式指定的位数后赋值给左侧变量。
>>=：将左侧变量的值右移右侧表达式指定的位数后赋值给左侧变量。
&=：对左侧变量和右侧表达式的值进行按位与操作后赋值给左侧变量。
^=：对左侧变量和右侧表达式的值进行按位异或操作后赋值给左侧变量。
|=：对左侧变量和右侧表达式的值进行按位或操作后赋值给左侧变量。

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

在Java中，运算符的优先级决定了表达式中运算的顺序。当一个表达式中包含多个运算符时，具有较高优先级的运算符会先于具有较低优先级的运算符进行计算。以下是从最高优先级到最低优先级的Java运算符列表：

1.括号 () - 用于改变运算顺序。

2.后缀运算符 ++（自增）、--（自减）。

3.前缀运算符 ++（自增）、--（自减）、+（正号）、-（负号）、!（逻辑非）、~（按位非）。

4.乘法、除法和取余运算符 *、/、%。

5.加法和减法运算符 +、-。

6.位移运算符 <<（左移）、>>（右移）、>>>（无符号右移）。

7.关系运算符 >、<、>=、<=。

8.相等性运算符 ==、!=。

9.按位与运算符 &。

10.按位异或运算符 ^。

11.按位或运算符 |。

12.逻辑与运算符 &&。

13.逻辑或运算符 ||。

14.条件运算符 ?:（三元运算符）。

15.赋值运算符 =、+=、-=、*=、/=、%=、<<=、>>=、>>>=、&=、^=、|=。

16.逗号运算符 , - 用于在一条语句中执行多个操作。

条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );

      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

补码原码反码

原码（Sign-Magnitude Representation）

原码是最直观的编码方式，它将一个数分为符号位和数值位两部分。在原码表示法中：

最高位是符号位，0 表示正数，1 表示负数。
其余位表示数值的绝对值。

示例:
假设我们使用8位来表示整数：

+5 的原码是 00000101。
-5 的原码是 10000101。

反码（Ones' Complement）

反码用于简化负数的表示。在反码表示法中：

正数的反码与其原码相同。
负数的反码是其原码除符号位外所有位取反（0变1，1变0）。

示例:

+5 的反码是 00000101（与原码相同）。
-5 的反码是 11111010（除符号位外，其他位取反）。

补码（Twos' Complement）

补码是计算机中最常用的编码方式，因为它简化了加法和减法的硬件实现。在补码表示法中：

正数的补码与其原码相同。
负数的补码是其反码加1。

示例:

+5 的补码是 00000101（与原码相同）。
-5 的补码是 11111011（反码 11111010 加1）。

数据类型的转换

数据类型

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	'u0000'
String (or any object)	null
boolean	false

public class Test {
    static boolean bool;
    static byte by;
    static char ch;
    static double d;
    static float f;
    static int i;
    static long l;
    static short sh;
    static String str;

    public static void main(String[] args) {
        System.out.println("Bool :" + bool);
        System.out.println("Byte :" + by);
        System.out.println("Character:" + ch);
        System.out.println("Double :" + d);
        System.out.println("Float :" + f);
        System.out.println("Integer :" + i);
        System.out.println("Long :" + l);
        System.out.println("Short :" + sh);
        System.out.println("String :" + str);
    }
}

自动数据类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

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

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

1. 不能对boolean类型进行类型转换。
1. 不能把对象类型转换成不相关类的对象。
1. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
1. 转换过程中可能导致溢出或损失精度，例如：
int i =128;
byte b = (byte)i;
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
1. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
(int)23.7 == 23; (int)-45.89f == -45

public class ZiDongLeiZhuan{
        public static void main(String[] args){
            char c1='a';//定义一个char类型
            int i1 = c1;//char自动类型转换为int
            System.out.println("char自动类型转换为int后的值等于"+i1);
            char c2 = 'A';//定义一个char类型
            int i2 = c2+1;//char 类型和 int 类型计算
            System.out.println("char类型和int计算后的值等于"+i2);
        }
}

强制数据类型转换

public class ForceTransform {
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}