Java语法基础

注释

注释并不会被执行,是给我们写代码的人看的

注释是一个非常好的习惯

平时写代码一定要注意规范

  • 单选注释

    //注释

  • 多行注释

    /*

    多行注释:可以注释一段文字

    */

  • 文档注释

    /**

    *@Description HelloWorld

    *@Author 穆可寒

    */

 

标识符

  • 关键字

     

1654176359638

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

标识符注意点

  • 所有的标识符都应该以字母(A-Z或a-z),美元符号($),下划线(-)开始

  • 首字符之后可以是字母美元符号、下划线数字的任意字符组合

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

  • 标识符是大小写敏感

  • 合法标识符举例:age、$salary、_value、__1_value

  • 非法标识符举例:123abc、-salary、#abc

  • 可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音

 

 

数据类型

public class Demo02 {
   public static void main(String[] args) {
       //八大基本数据类型
       //整数
       int num1 = 10;//最常用
       byte num2 = 100;//-128 - 127
       short num3 = 30;
       long num4 = 30L;//此数据类型需要在数字末尾加L

       //小数:浮点数
       float num5 = 50.1f;//末尾加f
       double num6 = 3.1415926;

       //字符
       char name = 'A';

       //字符串,String不是关键字,是类
//       String name1 = "穆可寨";

       //布尔值
       boolean flag = true;


  }
}

 

数据类型拓展

public class Demo03 {
   public static void main(String[] args) {
      //整数拓展:二进制0b 八进制0 十六进制0x
       int i = 10;
       int i1 = 0b10;
       int i2 = 010;//八进制0
       int i3 = 0x10;//十六进制0x 0-9 A-F
       System.out.println(i);
       System.out.println(i1);
       System.out.println(i2);
       System.out.println(i3);

       System.out.println("====================");
       //============
       //浮点数拓展? 银行业务怎么表示?
       //Bigdecimal 数学工具类 用于银行业务精准小数
       //=============
       //float 有限 离散 舍入误差 接近但不等于
       //double

       float f = 0.1f;    //0.1
       double d = 1.0/10; //0.1
       System.out.println(f==d); //false
       System.out.println(f);
       System.out.println(d);

       float d1 = 21212313213f;
       float d2 = d1 + 1;
       System.out.println(d1 == d2);


       //==================
       //字符拓展?
       //==================
       char c1 = 'a';
       char c2 = '中';
       System.out.println(c1);
       System.out.println((int)c1);//强制转换
       System.out.println(c2);
       System.out.println((int)c2);
       //所有的字符本质还是数字
       //编码 Unicode 表:(97 = a,65 = A),2字节 0-65536
       //U0000 UFFFF

       char c3 = '\u0061';
       System.out.println(c3); //a

       //转义字符
       // \t 制表符
       // \n 换行
       //....
       System.out.println("Hello\nWorld!");

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

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

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

 

类型转换

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

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

  • byte,short,char -> int -> long -> float -> double

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

 

  • 强制类型转换,由高到低

  • 自动类型转换,由低到高

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

 

变量

  • 变量是什么:就是可以变化的量!

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

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

    type varName [=value] 
    //数据类型 变量名 = 值
  •  

  • 注意事项:

    • 每个变量都有类型,类型可以是基本类型,也可以是引用类型。

    • 变量名必须是合法的标识符

    • 变量电暖是一条完整的语句,因此每一个声明都必须以分号结束

变量的作用域

  • 类变量

  • 实例变量

  • 局部变量

    public class Demo08 {
       //类变量 static
       static double salary = 2500;

       //实例变量:从属于对象,不需要初始化
       //布尔值:默认是false
       //除了基本类型,其余的默认值都是null
       String name;
       int age;

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

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

           //实例变量
           //变量类型 变量名字 = new 变量类型();
           Demo08 demo08 = new Demo08();
           System.out.println(demo08.age);
           System.out.println(demo08.name);

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


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

     

常量

  • 常量(Constant):初始化后不能再改变值!不会变动的值。

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

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

变量的命名规范

  • 所有变量、方法、类名:见名知意

  • 类成员变量:首字母小写和驼峰原则:monthSalary,除了第一个单词以外,后面的单词首字母大写

  • 局部变量:首字母小写和驼峰原则

  • 常量:大写字母和下划线:MAX_VALUE

  • 类名:首字母达到和驼峰原则:Man,GoodMan

  • 方法名:首字母小写和驼峰原则:run(),runRun()

 

运算符

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

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

    • 赋值运算符:=

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

    • 逻辑运算符:&&,||,!

    • 位运算符:&,|,^,~,>>,<<,>>>(了解)

    • 条件运算符:? :

    • 扩展赋值运算符:+=,-=,*=,/=

 

包机制

  • 为了更好的组织类,Java提供机制,用于区别类名的命名空间

  • 包的本质就是文件夹

  • 包语句的语法格式为:

    package pkg1[.pkg2[.pkg3...]];
  • package必须放在第一行

  • 一般利用公司域名倒置作为包名

  • 为了能够使用某一个包的成员,我们需要在Java程序中明确导入该包。使用"import"语句可以完成此功能

    import package1[.package2...].(classname|*);
    import com.mkz.*;//导入该包下的所有类
  • 导入包里面的类名不要与当前类名相同

 

JavaDoc 帮助文档生成

  • javadoc 命令是用来生成自己API文档的

  • 参数信息

    • @author 作者名

    • @version 版本号

    • @since 指明需要最早使用的jdk版本

    • @param 参数名

    • @return 返回值情况

    • @throws 异常抛出情况

Java流程控制

Scanner对象

  • 之前我们学的基本语法中我们并没有实现程序和人的交互,但是Java给我们提供了这样一个工具类,我们可以获取用户的输入。java.util.Scanner是Java5的新特性,我们可以通过Scanner类来获取用户的输入。

  • 基本语法:

    Scanner s = new Scanner(System.in);
  • 通过Scanner类的next()和nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

  • next():

    • 一定要读取到有效字符后才可以结束输入

    • 对输入有效字符之前遇到的空白,next()方法会自动将其去掉。

    • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

    • next()不能等到带有空格的字符串。

  • nextLine():

    • 以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。

    • 可以获得空白。

顺序结构

  • Java的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行

  • 顺序结构是最简单的算法结构。1654247393292

  • 语句与语句之间框与框之间是按从上到下的顺序进行的,它是由若干个依次执行的处理步骤结成的,它是任何一个算法都离不开的一种基本算法结构

选择结构

  • if单选择结构

    • 我们很多时候需要去判断一个东西是否可行,然后我们才去执行,这样一个过程在程序中的if语句来表示

    • 语法

      if(布尔表达式){
         //如果表达式为true执行的语句
      }

       

  • if双选择结构

    • 那现在有个需求,公司要收购一个软件,成功了,给人支付100万元,失败了,自己找人开发。这样的需求用一个if就搞不定了,我们需要有两个判断,需要一个双选择结构,所以就有了if-else结构。

    • 语法

      if(布尔表达式){
         //布尔表达式为true时执行的语句
      }else{
         //布尔表达式为false时执行的语句
      }

       

  • if多选择结构

    • 我们发现刚才的代码不符合实际情况,真实的情况还可能存在ABCD,存在区间多级判断。比如90-100就是A,80-90,就是B..等等,在生活中我们很多时候的选择也不仅仅只有两个,所以我们需要一个多选择结构来处理这类问题

    • 语法

      if(布尔表达式1){
         //如果布尔表达式1的值为true执行代码
      }else if(布尔表达式2){
         //如果布尔表达式2的值为true执行代码
      }else if(布尔表达式3){
         //如果布尔表达式3的值为true执行代码
      }else{
         //如果以上布尔表达式都不为true执行代码
      }

       

  • 嵌套的if结构

    • 使用嵌套的if...else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或者else if语句。你可以像if语句一样嵌套else if...else。

    • 语法:

      if(布尔表达式1){
         //如果布尔表达式1的值为true执行代码
         if(布尔表达式2){
             //如果布尔表达式2的值为true执行代码
        }
      }
    • 思考?我们需要寻找一个数,在1~100之间

  • switch多选择结构

    • 多选择结构还有一个实现方式就是switch case语句。

    • switch case语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。

    • 每个case后面要加上break

      switch(expression){
         case value:
             //语句
             break;//可选
         case value:
             //语句
             break;
            //你可以有任意数量的case语句
         default://可选
             //语句
      }
    • switch语句中的变量类型可以是:

      • byte、short、int或者char。

      • 从Java SE7开始,switch 支持字符串String类型了

      • 同时case标签必须为字符串常量或字面量。

     

循环结构

  • while循环

    • while是最基本的循环,它的结构为:

      while(布尔表达式){
         //循环内容
      }
    • 只要布尔表达式为true,循环就会一直执行下去。

    • 我们大多数情况是会让循环停止下来的,我们需要一个让表达式失效的方式来结束循环。

    • 少部分情况需要循环一直执行,比如服务器的请示响应监听等。

    • 循环条件一直为true就会造成无限循环【死循环】,我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃!

    • 思考:计算1+2+3+...+100=?

  • do...while循环

    • 对于while而言,如果不满足条件,则不能进入循环。但有时候我们需要不满足条件,也至少执行一次。

    • do...while循环和while循环相似,不同的是,do...while循环至少会执行一次。

      do{
         //代码语句
      }while(布尔表达式);
    • while和do-while的区别:

      • while先判断后执行,do-while是先执行后判断

      • do-while总是保证循环体会被至少执行一次!这是他们的主要差别。

  • for循环

    • 虽然所有循环结构都可以用while或者do...while表示,但Java提供了另一种语句---for循环, 使一些循环结构变得更加简单。

    • for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构。

    • for循环执行的次数是在执行前就确定的。语法格式如下:

      for(初始化;布尔表达式;更新){
         //代码语句
      }
    • 练习1:计算0到100之间的奇数和偶数的和

    • 练习2:用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个

    • 练习3:打印九九乘法表

  • 在Java5中引入了一种主要用于数组的增强型for循环

    • 这里我们先只是见一见,做个了解,之后数组我们重点使用

    • Java5 引入了一种主要用于数组或集合的增强型for循环。

    • Java增强for循环语法格式如下:

      for(声明语句:表达式){
         //代码句子
      }
    • 声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素值相等。

    • 表达式:表达式是要访问的数组名,或者是返回值为数组的方法

break continue

  • break在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)

  • continue语句用在循环语句体中,用于终止某次循环过程,即路过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。

  • 关于goto关键字

    • goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字,但并未在语言中等到正式使用;Java没有goto。然而,在break和continue这两个关键字身上,我们仍然能看出一些goto的影子---带标签的break和continue

    • “标签”是指后面跟一个冒号的标识符,例如:label:

    • 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环,由于break和continue关键字熊掌中中断当前循环,但若随同标签使用,它们就会中断存在标签的地方

 

Java方法

何谓方法

  • System.out.println(),那么它是什么呢?

  • Java方法是语句的集合,它们在一起执行一个功能。

    • 方法是解决一类问题的步骤的有序组合

    • 方法包含于类或对象中

    • 方法在程序中被创建,在其他地方被引用

  • 设计方法的原则:方法的本意是功能块,就是实现某个功能的语句块的集合。我们设计方法的时候,最好保持方法的原子性,**就是一个方法只完成一个功能,这样利于我们后期的扩展。

方法的定义

  • Java的方法类似于其它语言的函数,是一段用来完成特定功能的代码片段,一般情况下,定义一个方法包含以上语法:

  • 方法包含一个方法头和一个方法体。下面是一个方法的所有部分:

    • 修饰符:修饰符,这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。

    • 返回值类型:方法可能会返回值。returnValueType是方法的返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,returnValueType是关键字void。

    • 方法名:是方法的实际名称。方法名和参数表共同构成方法签名。

    • 参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或者变量。参数列表是指方法的参数类型、顺序和参数个数。参数是可选的,方法可以不包含任何参数。

      • 形式参数:在方法被调用时用于接收外界输入的数据。

      • 实参:调用方法时实际传给方法的数据。

    • 方法体:方法体包含具体的语句,定义该方法的功能。

      修饰符 返回值类型 方法名(参数类型 参数名){
        ...
          方法体
        ...
         return 返回值;
      }

方法调用

  • 调用方法:对象名.方法名(实参列表)

  • Java支持两盘调用方法的方式,根据方法是否返回值来选择。

  • 当方法返回一个值的时候,方法调用通常被当成一个值。例如:

    int larger = max(30,40);
  • 如果方法返回值是void,方法调用一定是一条语句;

    System.out.println("Hello,nihao!")  ;
  • 课后拓展了解:值传递和引用传递

方法的重载

  • 重载就是在一个类中,有相同的函数名称,但形参不同的函数。

  • 方法重载的规则:

    • 方法名称必须相同。

    • 参数列表必须不同(个数不同,或类型不同,参数排列顺序不同)。

    • 方法的返回类型可以相同也可以不同。

    • 仅仅返回类型不同不足以成为方法的重载。

  • 实现理论

    • 方法名称相同时,编译器会根据调用方法的参数个数、类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。

命令行传参

有时候你希望运行一个程序的时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

public class CommandLine{
   public static void main(String args[]){
       for(int i = 0; i < args.length; i++){
           System.out.println("args[" + i +"]:" + args[i]);
      }
  }
}

 

可变参数

  • JDK1.5开始,Java支持传递同类型的可变参数给一个方法。

  • 在方法声明中,在指定参数类型后加一个省略号(...).

  • 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通参数必须在它之前声明。

  • 也可以传入一个数组

    public static void printMax(double... numbers){
       if(numbers.length == 0){
           System.out.println("No argument passed");
           return;
      }
       double result = numbers[0];
       
       //排序
       for(int i = 1; i < numbers.length; i++){
           if(numbers[i] > result){
               result = numbers[i];
          }
      }
       System.out.println("The max value is :" + result);
    }

     

递归

  • A方法调用B方法,我们很容易不理解

  • 递归就是:A方法调用A方法!就是自己调用自己

  • 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

  • 递归结构包括两个部分:

    • 递归关:什么时候不调用自身方法。如果没有头将陷入死循环。

    • 递归体:什么时候需要调用自身方法。

数组

数组的定义

  • 数组是相同类型数据的有序集合

  • 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

  • 其中,每个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。

数组的声明创建

  • 首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法:

    dataType[] arrayRefVar;//首选的方法

    dataType arrayRefVar[];//效果相同,但不是首选方法
  • Java语言使用new操作符来创建数组,语言如下,

    dataType[] arrayRefVar = new dataType[arraySize];
  • 数组的元素是通过索引访问的,数组索引从0开始。

  • 获取数组的长度

    arrays.length

内存分析

  • Java内存分析

    1654500870548

  • 写代码画图分析内存!

    1654501347706

三种初始化

  • 静态初始化

    int[] a = {1,2,3};
    Man[] mans = {new Man(1,1),new Man(2,2)};
  • 动态初始化

    int[] a = new int[2];
    a[0] = 1;
    a[1] = 2;
  • 数组的默认初始化

    • 数组是引用类型,它的元素相当于类型的实例变量,因此数组一经分配空间,其中的每个元素也被按照变量同样的方式被隐式初始化了。

数组的四个基本特点

  • 其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。

  • 其元素必须是相同类型,不允许出现混合类型。

  • 数组中的元素可以是任何数据类型,包括基本类型和引用类型。

  • 数组变量属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

数组边界

  • 下标的合法区间:[0,length-1],如果越界就会报错;

    publ{ic static void main(String[] args){
       int[] a = new int[2];
       System.out.println(a[2]);
    }
  • ArrayIndexOutOfBoundsException:数组下标越界异常!

  • 小结:

    • 数组是相同数据类型(数据类型可以为任意类型)的有序集合

    • 数组也是对象,数组元素相当于对象的成员变量

    • 数组长度是确定的,不可变的。如果越界,则报:ArrayIndexOutOfBounds异常。

数组的使用

  • For-Each循环

  • 数组作方法入参

  • 数组作返回值

多维数组

  • 多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。

  • 二维数组

    int a[][] = new int[2][5];
  • 解析:以上二维数组a可以看成一个两行五列的数组。

  • 思考:多维数组的使用?

    num[1][0];

Arrays类

  • 数组的工具类java.util.Arrays

  • 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。

  • 查看JDK帮助文档

  • Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而“不用”使用对象来调用(注意:是“不用”而不是“不能”)

  • 具有以下常用功能:

    • 给数组赋值:通过fill方法。

    • 对数组排序:通过sort方法,按升序。

    • 比较数组:通过equals方法比较数组中元素值是否相等。

    • 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

冒泡排序

  • 冒泡排序无疑是最为的排序算法之一,总共有八大排序!

  • 冒泡排序的代码还是相当简单的,两层循环,外层 冒泡轮数,里层依次 比较,江湖中人尽皆知。

  • 我们看到嵌套循环,应该立马就可以得出这个算法的时间复杂度为O(n2)。

  • 思考:如何优化?

稀疏数组

  • 需求:编写五子棋游戏中,有存盘退出和续上盘的功能。

  • 分析问:因为该二维数组的很多值是默认为0,因此记录了很多没有意义的数据。

  • 解决:稀疏数组

  • 介绍:当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组。

  • 稀疏数组的处理方式是:

    • 记录数组一共有几行几列,有多少个不同值。

    • 把具有不同值的元素的行列及值记录在一个小规模的数组中,从而缩小程序的规模

  • 如下图:左边是原始数组,右边是稀疏数组1654519217652

  •  
posted @ 2022-06-06 21:45  crowdedStreet  阅读(62)  评论(0)    收藏  举报