Java基础语法

  1.Java语言的特点

    简单性、解释性、面向对象、高性能、分布式处理、多线程、健壮性

  多态、结构中立、安全性、开源、跨平台

  2.Java语言的关键字

   特点：组成关键字的字母全部小写

  在自己学习的过程中、会逐渐遇到不同的关键字、不要刻意的去背啊

  【熟能生巧】

  3.Java的标识符

   描述：就是给类、接口、方法、变量等起名字时使用的字符序列

   特点：由26个英文字母大小写、数字0~9、“_”、“$”组成

   规则

  （1）不能以数字开头

  （2）不能使用“_”、“$”以外的特殊符号

  （3）不能使用关键字

  （4）Java中严格区分大小写

   命名规范

  （1）包名：多单词组成时所有字母都小写

  （2）类名接口名：多单词组成时、所有单词的首字母大写

  （3）变量名和函数名：多单词组成时、第一个单词首字母小写

      第二个单词开始每个单词的首字母大写

  （4）常量名：所有字母都大写、多单词时每个单词用下划线链接

  4.Java注释

  （1）单行注释

// 这是单行注释

  （2）多行注释

/*
   这是多行注释
 */

  （3）文档注释

 /**
  *  这是文档注释
  */

  5.Java的常量

  描述：不能改变的数值

  分类

  (1)整数常量：所有整数

  (2)小数常量：所有小数

  (3)布尔常量（boolean）：只有 true 和 false

  (4)字符串常量：所有被英文双引号""括起来的标识内容

  (5)Null常量：只有一个null

 6.Java的变量

  描述：内存中的一个存储区域、该区域有自己的名称和类型

  该区域的数据可以在同一类型范围内不断变化

  特点：变量其实就是将不确定的数据进行存储、也就是需要

  在内存中开辟一个空间

基本数据类型

  (1)整数型

   byte 占一个字节 【-128到127】

  short 占两个字节 【-2^15到2^15-1】

  int 占四个字节 【-2^31到2^31-1】

 long 占八个字节 【-2^63到2^63-1】

  (2)浮点型

  float 占四个字节 【-3.403E38到3.403E38】

  double 占八个字节 【-1.798E308到1.798E308】

  (3)布尔型

  char 占两个字节 【0到65535】

  (4)布尔型

   boolean理论上是占八分之一个字节、只有true 和 false

 两个值、但是Java中boolean类型没有明确指定他的大小

【扩展】变量的注意事项

   (1)作用域问题

    同一个区域不能使用相同的变量名

//普通代码块   作用域的使用
  {   //   <--------  这是x的作用域
      int x = 3;
      {  //  <-------  这是y的作用域
          int y = 5;
      }
  }   // 两者相互不干涉

  (2)初始化值问题

  局部变量在使用之前必须赋值

 (3)一条语句可以定义多个变量

  一条语句指的是在一行上

int a, b, c;   // 注意中间用英文逗号隔开、不然报错

7.数据类型转换

 (1)自动类型转换

  默认转换（从小到大）  

 byte、short、char---> int ---> long ---> float ---> double

 (2)强制类型转换

  这里分享一个使用场景给大家吧、直接上代码

/**
         *   描述一下应用场景吧
         *   数据类型他本身就限制了有最大值和最小值
         *   就拿int类型来举例说明吧
         *   在给int类型赋值的时候、超过赋值范围的话
         *   肯定是要报错了
         *   但是、学会使用强制类型转换、来改变原int类型
         *   内部给定的最大值和最小值
         */

        //Integer  这个是包装类里面的知识、MAX_VALUE表示int类型的最大值
        //现阶段只需要、了解即可、我们后面在讲解
        int i = Integer.MAX_VALUE;

        System.out.println("原int类型最大值:" + i); //  最大值是:  2147483647

        long l = 2147483648l;  //  赋值后面加l是为了和int类型区分开来、当然不加会报错
        int q = 2147483647;
        l = (long) q;   // 强制转换改变原int类型最大值

        System.out.println("现在int类型最大值:" + (l + 1));  // 最大值是: 2147483648
        /*
           前提是你需要找一个比自身最大值范围还要大的数据类型才行
           所以
           int 找了 --------->  long  帮忙
           自身不能改变、但可以找别人帮忙
         */

注意：如果超出了被赋值的数据类型的取值范围得到的结果会与

 你期望的结果不同

(3)隐式转换

 描述：取值范围小的数据类型与取值范围大的数据类型进行运算

  会先将小的数据类型提升为大的、再运算

        int a = 15;
        double b = 1.5;
        double c = (a + b);

//        int d = (a + b);   // 这里会报错、 因为、他不是老大 哈哈
 
        System.out.println(c);  // 输出结果 16.5

        // 这是因为double类型所占用的字节要比int多
        // 所以 double 是老大  就要返回  -------->  double的一个值

8.Java的运算符

 描述：就是对常量和变量进行操作的符号

算术运算符：+ ，- ， *， %， ++， --

赋值运算符：+，+=，-=，*=，/=，%=

比较运算符：==，!=，>，>=，<，<=

注意：无论你的操作是简单还是复杂、结果是boolean类型

逻辑运算符：&，|，^，!，&&，||

注意：逻辑运算符一般用于连接boolean类型的表达式或者值

&&和&的区别（||和|的区别同理）

&&：具有短路效果、左边是false、右边不执行

&：无论左边是false还是true、右边都会执行

【主要来讲讲位运算符和三元运算符】

位运算符：^，~，>>，>>>，<<

^：一个数据对另一个数据位异或两次、该数本身不变

        int b = 3 ^ 16;  // 3 <---  这个是决定异或几次、也就是移动几次   16  是初始值

        System.out.println("^:" + b);  //  19

~：取反并且加上1

        int a = 15;

        System.out.println("取反:" + ~a);   // -16

<<：左移 左边最高位丢弃、右边补齐0

        int c = 1 << 3;

        System.out.println("<<:" + c); // 8

        /**
         *   这里先是把1 --->  转换为   二进制  --->  【00000】001 要凑齐八位数、不够补0  
         *   这是二进制的
         *   括号内是补的0
         *   然后向左移三位  --->   就是 --->  【0000】1000 ---> 结果也就是8  这是10进制的
         *   进制我后面跟大家讲解
         */

>>：右移 最高位是0、左边补齐0、最高位是1、左边补齐1

        int d = 5 >> 2;

        System.out.println(">>:" + d);   //   1

        /**
         *  这里先把5 --->  转换为  二进制  --->  101
         *  最高位是1、左边补齐1、是0、左边补齐0
         *  右移两位  --->   111【0001】  --->  结果是二进制的 1
         */

>>>：无符号右移 无论最高位是0还是1 左边补齐0

        int e = 5 >>> 2;

        System.out.println(">>>:" + e);  //  1
        //  结果和  >>  相同

三元运算符

(格式)：（关系表达式）? 表达式1 ：表达式2

这里分享一个应用场景、给大家吧、直接上代码

package day;    // 包名你们自己建立

import java.util.Scanner;   // 这里是自动导包

public class test05 {
    static Scanner sc = new Scanner(System.in);  // 公共的输入流

    static {    // 静态代码块 只执行一次
        System.out.println("请输入您所要投票的编号\n---(1第一种方案,2第二种方案)---");
    }

    public static void main(String[] args) {
        /**
         *   描述一下应用场景吧
         *   假如X公司、设计了两种方案
         *   老板看了都非常喜欢、但是又不好
         *   下决定、选择哪个方案来作为最终要实现的设计
         *   这时就要进行投票、哪个方案票数多
         *   就执行哪个方案的计划
         */
        test05 t = new test05();  //实例化对象
        t.show();   //调用投票区域
    }

    public void show() {   //投票区域的方法
        int one = 0; // 投第一种方案
        int two = 0; // 投第二种方案
        for (int i = 0; i < 7; i++) {   // 投票进行7次
            int vote = sc.nextInt(); // 开始投票
            if (vote == 1) {   // 投票判断
                System.out.println("第一种方案获得的票数是:" + ++one);
            } else if (vote == 2) {
                System.out.println("第二种方案获得的票数是:" + ++two);
            }
        }
        if (one > two) {  //最终票数判断
            System.out.println("恭喜第一种方案胜出!\n票数是:" + one + "\n执行第一种方案");
        } else {
            System.out.println("恭喜第二种方案胜出!\n票数是:" + two + "\n执行第二种方案");
        }
        Object result = ((one > two) ? One("最终票数:", one) : Two("最终票数:", two));  
           // 投票结果

        /**
         *   为什么要接收一个 Object 的一个类型呢？
         *   因为 Object 是 所有基本数据类型的超类
         *   如果是单方面接收一个String或者int类型的数据
         *   会产生一个类型不兼容的错误
         *   因为要同时接收一个String类型和一个int类型的数据
         *   用 Object类型 就可以解决 类型不兼容问题
         */

        System.out.println(result);   //输出结果
    }

    public Object One(String s, int count) {   // 返回第一种方案票数
        return s + count;
    }

    public Object Two(String s2, int count02) {  // 返回第二种方案票数
        return s2 + count02;
    }

    /*
        这里也可以改成方法的重载
        方法很多、这里大家去想一下
     */
}

运行结果

请输入您所要投票的编号
---(1第一种方案,2第二种方案)---
1
第一种方案获得的票数是:1
2
第二种方案获得的票数是:1
2
第二种方案获得的票数是:2
2
第二种方案获得的票数是:3
1
第一种方案获得的票数是:2
1
第一种方案获得的票数是:3
2
第二种方案获得的票数是:4
恭喜第二种方案胜出!
票数是:4
执行第二种方案
最终票数:4

9.进制

 (1)二进制：只有0和1 满2进1

 (2)八进制：0到7 满8进1、用0开头标识

 (3)十进制：0到9、满10进1

 (4)十六进制：0到9、A到F、满16进1 用0x开头标识

原码反码补码

 (1)源码

  就是二进制定点表示法、即最高位为符号位、“0”表示正

“1”表示负、其余位表示数值的大小

 (2)反码

 正数的反码与其原码相同、负数的反码是对其原码逐位取反

但符号位除外

 (3)补码

 正数的补码与其原码相同、负数的补码是在其反码的末位加1

10.方法

(1)方法的形参与实参

直接看图!!!

static Scanner s = new Scanner(System.in);  // 公共的输入流

    public static void main(String[] args) {
        test06 t = new test06();  //实例化对象
        // 这里通过动态的形式获取 int类型的变量的【实参】
        System.out.println("int类型的变量i的实参是:" + t.message(s.nextInt()));
    }

    //定义一个有参的构造方法、用于解释什么是实参和形参!
    public int message(int i) {
        return i;
        /**
         *   有参构造方法是一定要有 return 返回值的
         *   返回的是 int类型的变量  i
         *   但是没有明确说明 i 的内容是什么
         *   简单可以理解为
         *   形参 就是 --->  拿一个什么类型的盒子出来
         *   什么类型的盒子就是、专门装指定物品的、比如：【书本】、篮球、玩具等等...
         *   拿书本来举例
         *   实参 就是--->  书本的本身了、 如《平凡的人生》 《活着》
         *   这就是形参与实参的区别
         */
    }

 (2)方法的重载

 直接看图吧!!!

public class test07 {

    public static void main(String[] args) {
        test07 t = new test07();
        t.test07();
        t.test07(5);
    }

    /**
     *  方法的重载就是通过使用本类的类名而创建的构造方法
     *  【只是】
     *  1.参数列表不同
     *  2.参数个数不同
     *  3.参数对应的数据类型不同
     *  注意：如果两个方法是一样的话、会出现报错
     *  简单理解为
     *  一对双胞胎
     *  他们的性格、身高、体重、穿衣风格、头发的长度都会有所不同
     *  这就是方法的重载
     */

    public void test07() {
        System.out.println("这是无参的构造方法里的内容");
    }

    public void test07(int i) {
        System.out.println("这是有参但无返回值的构造方法的内容：" + i);
    }
}

 (3)方法的重写

直接看图!!!

public class test08 {
    static Scanner s = new Scanner(System.in);  //公共的输入流

    static test08 t = new test08();  // 实例化对象

    private int age;   //把年龄给封装起来

    public static void main(String[] args) {
        t.setAge(s.nextInt());  // 动态获取age的值
        System.out.println(t.toString()); // 输出age的值
    }

    public int getAge() {   // 获取age的值
        return age;
    }

    public void setAge(int age) {  //设置和约束age的值
        if (age <= 0) {
            System.out.println("你输入的年龄不合符逻辑");
            System.exit(-1);  // 调用System类中的exit()函数方法、用于结束程序的执行
        }
        this.age = age;
    }

    @Override   // 这是重写方法的声明
    public String toString() {
        return "年龄是：" + t.getAge();
        /**
         *  方法的重载就是改变一个方法中原有的内容、使其有不同的效果
         */
    }
}

11.数组和二维数组

大家还是看图吧、多敲敲代码!!!

public class test09 {
    static Scanner sc = new Scanner(System.in);   //公共的输入流

    public static void main(String[] args) {
        test09 t = new test09();
        t.message();
    }

    public void message() {
        // 定义一个int类型的数组

        /**
         *  创建数组的形式有很多种
         *  1.给出数组长度的
         *  2.创建动态的
         *  3.直接书写值的
         */

        int[] array = new int[3];

        //来玩个小游戏吧、就叫它数字入库吧
        for (int i = 0; i < 3; i++) {  // 进行三次
            int a = sc.nextInt(); // 设置局部变量
            if (a == 1) {  // 判断输入的数字
                array[0] = a;  // 如果是1的话、就把1存放到array数组中的第一个位置上
            } else if (a == 2) {
                array[1] = a;
            } else if (a == 3) {
                array[2] = a;
            } else {  // 如果不为 !1!2!3 的话就结束程序的执行
                System.exit(-1);
            }
        }

        // 遍历数组中的元素、并且输出
        System.out.println("数组中的元素是:");
        for (int Array : array) {
            if (Array != array.length - 1) {
                System.out.print(Array + "\t");
            } else {
                System.out.print(Array + "\t");
            }
        }
    }
}

分享几个在IDEA集成开发工具中使用的快捷键

1.psvm --->  点击回车  --->  快速生成 main()方法
2.sout --->  点击回车 --->  快速生成  输出语句

3.Ctrl + Alt + L 是 格式化代码 

希望能帮助到大家、哪怕一点点也足以

有什么写的不足和建议的、评论区见、最后呢

小亮厚着脸皮来跟大家要个赞和关注、谢谢大家!

【不定时更新】