首页 > 编程语言 >Java基础

Java基础

时间:2024-02-13 21:22:45浏览次数:34  
标签:Java String int 基础 System println public out

java基础

一、注释

image-20240208152955801

二、标识符和关键字

关键字:

img

标识符

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

标识符注意点:

  • 所有的标识符都应以字母(A-Z或者a-z),美元符($)、或者下划线(_)开始
  • 首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线(_)或数字的任何字符组合
  • 不能使用关键字作为变量名或方法名
  • 标识符是大小写敏感的
  • 合法标识符举例:age、$salary......
  • 非法标识符举例:123abc、-salary、#abc
  • 可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音

三、数据类型

Java是强类型语言:要求变量的使用要严格符合规定,所有的变量必须先定义后才能使用

Java的数据类型分为两大类:基本类型和引用类型

基本数据类型

数值类型

整数类型

byte占一个字节,范围:-128~127

short占2个字节,范围:-32768~32767

int占4个字节,范围:-2147483648~2147483647

long占8个字节,范围:-9223372036854775808~9223372036854775807

浮点类型

float占4个字节

double占8个字节

字符类型

char占2个字节

boolean类型

boolean占1位其值只有true和false两个

引用数据类型

类、接口、数组

代码展示

public class Demo02 {
    public static void main(String[] args) {
        //八大基本数据类型
        //整数
        int num1=10;
        byte num2=20;
        short num3=30;
        long num4=30L;//Long类型要在数字后面加L

        //小数:浮点数
        float num5=20.1F;//float类型要在数字后面加个F
        double num6=3.1415926;

        //字符类型
        char name='a';
        //字符串,String不是关键字,是个类
        String namea="xiaochen";

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

    }
}

数据类型的扩展

image-20240212160601158

image-20240212160638427

image-20240212160843384

image-20240212160910770

什么是字节

  • 位(bit):是计算机内部数据储存的最小单位,11001100是一个八位二进制数。

  • 字节(byte):是计算机中数据处理的基本单位,习惯上用大写B来表示,1B(byte,字节)=8bit(位)

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

  • 1bit表示1位

  • 1Byte表示一个字节 1B=8b

    • 1024B=1kB
    • 1024KB=1M
    • 1024M=1G

四、类型转换

  • 由于java是强类型语言,所以要进行有写运算的时候,需要用到类型转换。

    下面的图片展示的是各个类型的容量的由低到高:(为什么浮点数在整数之后,因为小数的优先级大于整数)

    image-20240212161347856

  • 运算中,不同类型的数据先转化为同一类型,然后进行运算。

    image-20240212164659163

image-20240212164723646

五、变量、常量、作用域

1、变量

  • 变量是什么?就是可以变化的量

  • Java是一种强类型的语言,每个变量都必须声明其类型。

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

    image-20240212210112982

  • 注意事项

    • 每个变量都有类型,类型可以是基本类型,也可以是引用类型
    • 变量名必须是合法的标识符
    • 变量声明是一条完整的语句,因此每一个声明都必须以分号结束

代码如下:

public class Demo06 {
    public static void main(String[] args) {
        //int a,b,c;不建议这样定义
        //int a = 1,b = 2,c = 3;不建议这样定义 程序可读性
        String name = "rex";
        char x = 'y';
        double pi=3.14;

    }
}

变量作用域

  • 类变量
  • 实例变量
  • 局部变量
public class Demo07 {
    //类变量 static
    static double salary = 2500;
    //属性:变量

    /*
    实例变量:从属于对象;如果不自行初始化,则会变成这个类型的默认值;
    所有的数值类型,其默认值为0或0.0
    布尔值默认为false
    除了基本类型其余的默认值都是null;
     */
    String name;
    int age;
    //char c;

    //main方法
    public static void main(String[] args) {//局部变量生命周期从此开始
        //局部变量:在方法内部,使用之前必须声明和初始化值。
        //局部变量的生命周期从方法的第一个大括号开始,第二个大括号结束
        int i = 10;
        System.out.println(i);
      //变量类型 变量名字= new Demo08();
        Demo07 demo07 = new Demo07();
        System.out.println(demo07.age);
        System.out.println(demo07.name);
        //System.out.println(demo07.c);
        System.out.println(salary);

    }//局部变量生命周期在此结束
    //其他方法
    public void add(){
        //System.out.println(i);i只在main方法中有效,在此方法中无效
    }
}

2、常量

  • 常量:初始化之后不能再改变值!不会变动的值

  • 所谓常量可以理解成一种特殊的变量,它的值被设定后,在程序运行过程中不允许被改变。

    final 常量名=值;
    final double PI=3.14;    
    
  • 常量名一般用大写字符。

    public class Demo08 {
        //static、final为修饰符,不存在先后顺序
        static final double PI=3.14;
        final static double HI=3.28;
        public static void main(String[] args) {
            System.out.println(PI);
            System.out.println(HI);
        }
    }
    

3、变量的命名规范

  • 所有的变量、方法、类名:见名知意
  • 类成员变量(即除去常量之外的变量):首字母小写和驼峰原则:monthSalary,除了第一个单词以为,后面的单词首字母大写如:lastName;
  • 局部变量:首字母小写和驼峰原则
  • 常量:大写字母和下划线:MAX_VALUE
  • 类名:首字母大写和驼峰原则:Man,GoodMan;
  • 方法名:首字母小写和驼峰原则:run(),runRun();

六、基本运算符

  • java语言支持如下运算符:

    • 算术运算符:+、-、*、/、%、++、--

      public class Demo01 {
          public static void main(String[] args) {
              //二元运算符
              //idea快捷键:Ctrl+D复制当前行到下一行
              int a=10;
              int b=20;
              int c=25;
              int d=25;
              System.out.println(a+b);
              System.out.println(a-b);
              System.out.println(a*b);
              System.out.println(a/(double)b);//当两个整数相除,结果出现小数的时候,记得强制类型转换
          }
      }
      
      public class Demo02 {
          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
              /*
              为什么会出现这些不同类型的结果呢?
              当操作数当中有一个类型为Long,那么结果类型也为Long
              如果没有Long,结果都为int,无论是否有int类型的操作数
               */
          }
      }
      
      public class Demo04 {
          public static void main(String[] args) {
              //++即自增 --即自减 一元运算符
              int a = 3;
              int b = a++; //执行完这行代码后,先给b赋值,赋值完之后再自增
              //a++即a = a+1;
              System.out.println(a);
              //++a即 a = a+1;
              int c = ++a;//执行这行代码前,先自增,再给b赋值
      
              System.out.println(a);//5
              System.out.println(b);//3
              System.out.println(c);//5
      
              //幂运算2^3 2*2*2 = 8 很多运算我们会使用一些工具类来操作
              double pow = Math.pow(3,2);
              System.out.println(pow);
          }
      }
      
    • 赋值运算符:=

    • 关系运算符:>、<、>=、<=、==、!=、 instanceof

      public class Demo03 {
          public static void main(String[] args) {
              //关系运算符的返回结果:正确 错误 布尔值
              //if
              int a=10;
              int b=20;
              int c=21;
              //取余也叫模运算
              System.out.println(c%a);//相当于c/a的余数 相当于21/10=2……1
      
              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) {
              // 与(and)、或(or)、非(取反)
              boolean a = true;
              boolean b = false;
      
              System.out.println("a && b:"+(a&&b));//逻辑与运算,两个变量都为真结果才为真
              System.out.println("a || b:"+(a||b));//逻辑或运算,两个变量有一个为真,则结果为真
              System.out.println("!(a && b):"+!(a&&b));//如果是真则为假,如果是假则为真
      
              //短路运算
              int c = 5;
              boolean d = (c<4)&&(c++<10);
              System.out.println(d);//false
              System.out.println(c);//5
              /*
              这里c的值仍为5的原因是,第一个条件都为假,因为是短路与,所以后面的条件不用执行
               */
      
      
              System.out.println(++c<6);//false
              /*
              这里的false是因为两个加号在c前面,先执行了c=c+1的运算,之后才与6进行了比较
             若将条件改为c++<6,则会产生true,这是因为两个加号在c后面,先与6进行了比较,才执行的c=c+1的运算
               */
              System.out.println(c);//6
          }
      }
      
    • 位运算符:&、|、^、~、>>、<<、>>>(了解!!!)

      public class Demo06 {
          public static void main(String[] args) {
              /*
               A = 0011 1100
               B = 0000 1101
          与   A&B 1100 1100 对应位都为1才得1,否则得0。
          或   A|B 0011 1101 对应位都为0结果为0,否则为1.
          异或  A^B 0011 0001 如果两个位置相同则为0,不相同则为1
          非    ~B  1111 0010 按位取反,是0变成1,是1变成0
      
      
              2*8怎么运算最快?
              运用位运算,效率极高
          左移 << 左移一位相当于数字乘2
          右移 >> 右移一位相当于数字除2
          如:
          0000 0000    0
          0000 0001    1
          0000 0010    2
          0000 0011    3
          0000 0100    4
          0000 1000    8
          0001 0000    16
               */
              System.out.println(2<<3);//16
              /*
              这里相当于2左移了三位,即2乘了三个2。
              */
          }
      }
      
    • 条件运算符:?:

      //三元运算符
      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);
          }
      }
      
    • 扩展赋值运算符:+=、-=、*=、/=

      package operator;
      
      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类型
              就会把另外一个操作数或者其他操作数都转换成String再进行连接
               */
      
              System.out.println(a+b);
              System.out.println(""+a+b);
              System.out.println(a+b+"");
              /*
              System.out.println(""+a+b);//结果为1020
              System.out.println(a+b+"");//结果为30
              这两个结果有什么区别?
              第一个结果为1020,第二个结果为30。当字符串在前面会进行拼接,在后面会先进行运算
              个人理解是因为当在执行这个代码的时候,当字符串在前面的时候,先读到了字符串,然后进行了拼接
              当字符串在后面的时候,先读到了两个操作数的运算,之后才读到字符串。
               */
          }
      }
      

七、运算符的优先级

image-20240213210717446

八、包机制

  • 为了更好地组织类,Java提供了包机制,用于区别类名的命名空间(包的本质就是一个文件夹)
  • 一般利用公司域名倒置作为包名。例如:包名可以这样写 com.chen.xxx
  • 为了能够使用某一个包的成员,我们需要在Java程序中明确导入该包,使用“import”语句即可完成此功能

九、JavaDoc生成文档

  • javadoc命令是用来生成自己API文档的
  • 参数信息
    • @author 作者名
    • @version 版本号
    • @since 指明需要最早使用的jdk版本
    • @param 参数名
    • @return 返回值情况
    • @throws 异常抛出情况
/**
 * @author kuangshen
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

    /**
     *
     * @param name
     * @return
     */
    public String test(String name){
        return name;
    }

    /**
     * 
     * @param name
     * @return
     * @throws Exception
     */
    public String test1(String name) throws Exception{
        return name;
    }
}

在中端输入以下命令,可以生成javadoc文档,中间的一些命令是为了让我们的一些参数显示的更为正常。

image-20240213205459918

标签:Java,String,int,基础,System,println,public,out
From: https://www.cnblogs.com/chenmochen/p/18014822

相关文章

  • DFS基础与回溯
    回溯法简介回溯法一般使用DFS(深度优先搜索(递归))实现,DFS是一种遍历或搜索图,树或图像等数据结构的算法。上述数据结构不保存下来就是回溯法。常见的是搜索树,排列型搜索树(节点数一般为n!)与子集型搜索树(节点数一般为2n)。DFS从起始点开始,沿着一条路尽可能深入,直到无法继续回溯到上......
  • 基础数据结构笔记
    链表与邻接表:树与图的存储 单链表  画个图就很好理解了   例题826.单链表acwing——826.单链表_awcing826-CSDN博客实现一个单链表,链表初始为空,支持三种操作:(1)向链表头插入一个数;(2)删除第k个插入的数后面的数;(3)在第k个插入的数后插入一个数现在要......
  • 第二章 语法基础
       目  录1.第一个Python程序 2.数据与数据类型 3.数据类型转换 4.标识符 5.变量 6.常量 7.Python运算符 8.表达式 9.语句 10.实例: 语法基础    任何一段计算机程序都是由一组计算机能够理解的指令构成,其中每条指令都表现为遵循......
  • 2024牛客寒假算法基础集训营3
    M题智乃的36倍数(normalversion)错解幂运算写成了乘~#include<bits/stdc++.h>usingnamespacestd;#defineendl'\n'#defineintlonglong#definedebug(x)cout<<x<<""<<endl;#define_debug(a,n)for(inti=0;i<n;i++)......
  • JDK21报错 java: java.lang.NoSuchFieldError: Class com.sun.tools.javac.tree.JCTre
    JDK21报错java:java.lang.NoSuchFieldError:Classcom.sun.tools.javac.tree.JCTree$JCImportdoesnothavememberfield'com.sun.tools.javac.tree.JCTreequalid'Lombok版本兼容性的问题导致Maven依赖改为新版本<dependency><groupId>org.projectlombok&l......
  • 网络通信基础知识学习笔记
    一.图解网络为什么需要TCP/IP网络模型:为了适应互联网环境下多种多样的设备,设计的一套通用的网络协议对于同一台设备进程间的通信方式:管道,消息队列,共享内存,信号量TCP/IP网络模型的分层:应用层:用户能够直接接触到的层次,互联网软件都是在应用层进行实现.......
  • javacv模块依赖简化
    前言JavaCV更新到1.5.x版本,依赖包也迎来了很大变化,体积也变大了不少。由于javacv跨平台,那么全部javacv依赖包下载下来后,整个javacv的包会特别巨大,接近1G.显然很多平台依赖包我们并不需要,而且我们开发时只需要自己本身开发平台的依赖包就可以了JavaCV1.5.x和之前版本已经不兼容J......
  • p5js: JavaScript 创意绘画
    p5js是一个免费开源的Javascript创意绘画工具,通过p5js可以实现代码绘画01鼠标变色鼠标触发绘画区域,即马上变色,松开恢复functionsetup(){createCanvas(400,400);//设置画布大小}functiondraw(){if(mouseIsPressed)//被鼠标触发{background(255,51,......
  • python基础学习5-面向对象
    类创建class类名():#类名首字母大写,()可写可不写pass对象对象名=类名()类的组成classStudent:school='北京xx学校'#类属性,定义在类中方法外的变量#初始方法def__init_......
  • 2024牛客寒假算法基础集训营1
    2024牛客寒假算法基础集训营1A解题思路:按照\(dfs\)出现顺序暴力判断即可。代码:#include<bits/stdc++.h>usingnamespacestd;usingll=longlong;usingpii=pair<ll,ll>;#definefifirst#definesesecondusingi128=__int128_t;usingpiii=pair<ll,pai......