java初级入门，java初级

来源： javaer 分享于 2019-06-16 点击 10239 次点评：168

java初级入门，java初级

java初级入门

什么是java
java的组成
eclipse的快捷键
java的基本语法
java的基本数据类型
java运算符

什么是java

什么是java？搜狗百科的解释是这样的：Java是一种可以撰写跨平台应用程序的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。
跨平台、面向对象（接口）、通用性、高效性、可移植性、安全性就是java的主要特点。

java的组成：java由四个方面组成：

eclipse的快捷键

eclipse是一个框架平台，是一个自由的集成开发环境（IDE，integrated Development Environment）是提供程序开发环境的应用程序。eclipse主要用来java语言的开发。

ctrl+d: 删除一行
CTRL+z:撤销操作
代码助手: alt+/
快速修正：ctrl +1
格式化代码： CTRL+shift+F
组织导入：ctrl+shift+o 取消导入
查看某一个人类的源代码：CTRL+点进去
打开继承体：CTRL+t
打开资源：CTRL+shift+r
打开类型：CTRL+shift+T
上下移动选中的行：Alt+up/dowm
上下复制选中的行：CTRL+alt+up/down
单行注释：CTRL+/
多行注释：CTRL+shift+\
取消多行注释：CTRL+shift+/
变为大/小写:CTRL+shift+X/Y
重命名：alt+ctrl+R
查找：Ctrl+F

本次代码运行环境都为JDK1.8

java的基本语法

//基本输出语句
public class Demo01 {
   public static void main(String[] args){
       System.out.println("1111");
       System.out.println("2222");
       System.out.print("3333");
       System.out.print("4444");//ln换行

   }
}
--------------
//声明一个变量为int类型
int year;
System.out.println(year);
//会发现编译错误，提示变量没有初始化
     int age;
      age=100;
System.out.println(age);
{
     int score=99;
//重复定义，编译错误
   //int age=80;
      age=33;
      System.out.println(score);
      System.out.println(age);  
}
//总结：
1.变量必须声明，必须初始化化后才能使用
2.变量可以改变值
3.变量拥有作用域，离开作用域，会自动回收
4.变量在作用域中，不能重复定义

java的字面量和常量

public class Demo03 {
   //成员变量，直接定义在类中
    String name="will";
public static void main(String[] args) {
   /*    
        常量 1，2，3
    常量：程序固定的不变化的量
    常量的分类
    字面值常量：一個写死/直接写出的值
    布尔常量：true/false
    定义的final常量:多态
    */
    System.out.println(2);
    System.out.println(1);
//  变量：表示存储空间，可以用來存放某一类型的常量值
//  沒有固定值，也可以是某种类型的未知数据
    int x=2;
    int y=3;
    int age=17;//表示年龄
    System.out.println(age);
    age=90;//重新把90的赋值/存储到age这个空间里面
    System.out.println(age);
    System.out.println(x+y);
    //也可写为：
    x=6;
    y=3;
    System.out.println(x+y);
    //美观
    --------------------
    /*变量的分类
     * 两大类：根据变量定义在类中的位置不同：
     * 1）成员变量
     * 直接定义在类里的变量，又称之为全局变量或字段
     * 
     * 2）局部变量
     * 除了成员变量，其他的都是局部变量。
     * 3种表现形式：方法形参，方法内变量，代码块变量。
     * 
     * 变量的作用域：
     *   作用域是定义在开始的{到定义所在的花括号}结束。
     * 变量的使用规则：
     * 1.变量必须先声明，并且初始化之后才能使用
     * 2.声明变量必须有数据类型
     * 3.同一作用域变量不能重复定义
     * */

    *//java编程的就近原则*

    /*java表达式
     *表达式：是由数字，运算符，数字分组符号（括号），变量
     *等能够求得结果的有意义的排列的组合。 
     * 1）直接用运算符连接的变量/常量可以称为表达式    
     * 如：
     *   a;
     *   a+b;
     *   3.14+a;
     *   (x+y)*z+100;
     *   表达式中操作数进行运算得到的最终的结果就是表达式结果。
     * */

数据类型和分类

public class Demo04 {
   public static void main(String[] args) {
/*
* java的数据类型
*分为两种：
*1）基本数据类型，又称为原生数据类型
*2）引用数据类型，又称为对象数据类型
*--------------------------
*8大基本数据类型：
*数值类型： 占位字节 数据范围 默认值
*整数:byte 1 [-128 127] 0 int 4 short 2 long 8 0L
*小数:float 4 0.0F double 8 0.0D 
*字符类型：符号 char 2 \u0000
*
*布尔类型：boolean 1位 false
*---------------------------
*引用类型：
*类
*接口
*数组
*/   
//基本数据类型仅仅是容量的大小不一样而已
      /* 四种表现形式
       * 二进制:0B或0b开头（java7的新特性） int a=0B110;
       * 八进制:要求以0开头 int a =012;
       * 十进制：一般使用int a=17;
       * 十六进制：要求0X或者0x int a=0x12;
       * java语言的整型常量的默认类型：int型
       * java语言的小数型常量的默认类型：double型
       * 建议声明long用L
       * */

    byte b1=126;
//  强制转换
    byte b2=(byte)(b1+1);
    System.out.println(b1);
    System.out.println(b2);
    System.out.println("---------------------");
    //byte的包装类
    byte bMax=Byte.MAX_VALUE;
    System.out.println(bMax);
    byte bMin=Byte.MIN_VALUE;
    System.out.println(bMin);
    byte b3=(byte)(bMax+1);
    System.out.println(b3);//-128  二进制

    long L=30;
    int i=(int)L;
    int iMax=Integer.MAX_VALUE;
    System.out.println(iMax);//214748364;
    //int a=2147483647;
        long a1=2147483647L;
    int a=(int)2147483647L;
        System.out.println(a1);
    /**
     * char类型：
     * 表示16位无符号整数或者Unicode字符
     * Java对字符采用Unicode的字符编码
     * Unicode收集了世界上所有语言文字中的字符，是一种跨平台的编码方式，java字符占两个字节，可以表示一个汉字
     * 什么编码？
     * 计算机只能表示0和1的两个数，比如a用97表示
     * ASCII
     * ---------------
     * char常量3种表现形式：
     * 1.直接使用单个字符来指定字符常量如‘A’
     * 2.直接作为整数类型使用，如‘97’
     * 3.和2一样，表示的是16进制‘\u0061’
     * */
    char c1='a';
    char c2='中';
    char c3='\u0061';
    char c4=97;
    char c5='\n';
    char c6='\t';
    System.out.println(c1);
    System.out.println(c2);
    System.out.println(c3);//a
    System.out.println(c4);//a
    System.out.println(c5);
    System.out.println(c6);

    //浮点型
    //float f1=5.0;
    /**
     * 小数常量：
     * 方式1；直接使用小数点表示：3.14
     * 方式2；使用科学计数法：2.14E2----2.14×10的2次方
     *** 小数的常量，默认是double类型**
     * 表示float，后跟上F或f
     *注意点：
     *无论是float还是double类型，double不能精确表示一个小数
     *在开发中，表示精确的数字，比如金钱 使用：Bigcimal类来解决 
     * **/

//    boolean
    //C语言中：0 1 
    // true false 
    //通常用于逻辑运算和程序流程控制
    //在JVM中对布尔的处理
    //也是用0表示false   非0表示true
    boolean isMan=false;
    if (isMan) {
        System.out.println("是男人");
    }else {
        System.out.println("不是男人");
    }
}
}

自增与自减运算符

//自增和自减
public class Demo06 {
public static void main(String[] args) {
    /**
     * 自增++
     * 自减——
     * 前置 后置
     * y1=++x1;
     * x1==11;
     * y1=x1+1;
     * 
     * */
    int x1=10;
    int y1=++x1;
    System.out.println("x1="+x1);//11
    System.out.println("y1="+y1);//11
    /**
     * y2=x2++;
     * x2原始值（10）;
     * y2得到是原始值
     * x2+1;
     * x2==11;
     * */
    int x2=10;
    int y2=x2++;
    System.out.println("x2="+x2);//11
    System.out.println("y2="+y2);//10

    int num1=1;
    num1=num1++;
    System.out.println(num1);//1
    int num2=1;
    num1=++num2;
    System.out.println(num2);//2

    **// ++在前先++，++在后后++
    //++i表示，i自增1后再参与其它运算；而i++ 则是i参与运算后，i的值再自增1。**
    /*前置后置区别的举例
    a = i++;
    相当于 a = i; i++;
    a = ++i;
    相当于 i++; a = i;
    */

}
}

测试：
int i=5;
i++;
System.out.println(“i=”+i);
++i;
System.out.println(“i=”+i);
int a=++i;
System.out.println(“a=”+a);
System.out.println(“i=”+i);
int b=i++;
System.out.println(“b=”+b);
System.out.println(“i=”+i);

数据过大或溢出

//数据过大和溢出
public class MaxAndMin {
  public static void main(String[] args) {
    /**
     * 当要表示数据超出数据类型的临界范围时，称为溢出。
     * 溢出情况发生时程序并没有做数据范围检查处理，此时会出现数据紊乱的情况。
     * 
     * */
     int iMax=Integer.MAX_VALUE;
     System.out.println("int max"+iMax);

     int max=2147483647;
      max=max+1;
      System.out.println(max);//-2147483648

      int min=-2147483648;
      min=min-1;
      System.out.println(min);//2147483647
      //int类型的范围：[-2147483648,2147483647]

String引用数据类型

public class StringDemo {
public static void main(String[] args) {
    /**java引用类型：类 接口 数组
     * -----------------
     * 什么是字符串：
     * 除了8种 基本数据类型，其他所有类型都是引用类型，包括类，接口，数组。
     *** 引用类型默认初始值都是null**
     * sting是一个类，表示字符串，一串字符，也就是N个字符连接在一起。
     * 字符串都是使用“”括起来，连接字符串使用“+”符号
     * 任何数据类和String相（+）连接，结果都是一个新的字符串
     * */
    String userName=new String();
    userName="我是帅哥";
    String userName2="我是帅哥2";
    System.out.println(""+userName);

    int age=17;
    System.out.println("年龄"+age);
//  转义字符：输出“你好帅哥”
    System.out.println("\"你好帅哥\"");
    System.out.println(8+7+"Hello");
    System.out.println("Hello"+8+7);
    System.out.println(8+"Hello"+7);
    System.out.println("Hello"+8.4245+7);
    System.out.println(8+"Hello"+100000000+7);
    //string是引用类型
    //不兼容的类型，string无法转换为int
    //int xx=(string)("ABC");
    //String yy=(String)123;
    //String yy=(int)123;
}
}

基本数据类型的转换

public class TypeConverDemo {
 public static void main(String[] args) {
    /**在8大基本数据类型中，boolean不属于数值类型，不参与转换
     * 基本数据类型转换：
     * 方式1：自动类型转换->隐式类型转换
     * 方式2：强制类型转换->显示类型转换
     * 遵循的规则：
     * 1:小数据转大数据，系统可以完成自动转换
     * 2：大数据转小数据，需要加强制转换符
     * 溢出和精度损失
     * */
     byte abc=2;
     double bca=abc;
     //int ddd=bca;
     //小往大赋值，可以。
     //大往小赋值，不可以。

//   自动类型转换    
     byte b=17;
     short s=b;
     int i=s;
     float f=i;
     double d=f;
    // byte b2=d;//错误:不兼容的类型，从double转换到byte的时候可能会有损失

     System.out.println(d);
//   需求：强制的把double类型的d转换为int类型
     int num=(int)d;
     System.out.println(num);
     int num2=(int) 3.1415926;
//   强转的缺点：精度损失
     System.out.println(num2);
     **//表达式类型自动提升**
     /**
      *算术表达式中包含多个基本数据类型（Boolean除外）
      * 规则：所有的byte，short，char类型被自动提升到int类型
      * 注意：
      * 1）整个表达式的最终结果被提升到表达式中最高的类型。
      * 2）任何类型的数据值和String相连接（+）结果都是string类型。
      * */
 }
}

赋值逻辑三元、三目

public class AssgingDemo {
public static void main(String[] args) {
    /*
     *赋值 
     * = += -= *= /= %=
     * */
      int age;
      age=17;//右边的值赋值给左边
      int x=10;
      x+=5;
      System.out.println(x);
      short s=123;
      s=(short)(s+10);
      System.out.println(s);

      short s1=123;
      //s1=s1+10;
      s1+=10;//隐式转换
      System.out.println(s1);

      /*比较运算符
       * == != <> <= >=
       */
       int a=4; 
       int b=3;
       System.out.println(a==b);
       System.out.println(a!=b);
      /**
       * 三目运算、三元运算
       * */
       int a = 10;
       int b = 20;
       int c  ;
       if(c =a >b){
         System.out.println(c);
       }

       /*
        * 给一个小数，需求求出四舍五入的结果？
        * double num=4.56; 5
        * double num1=4.44; 4
        * 四舍五入；
        * 思路：进行判断，num的小数部分和0.5的大小关系。
        * 小数部分>=0.5; 5;反之
        * 解决这个问题的方法：三元运算
        * boolean类型表达式 ？ 值1：值2;
        * */
       double num=4.56;
       //整数部分
       int iNum=(int)num;
       //小数部分
       double dNum=num-iNum;
       System.out.println(dNum);
       //三元运算
       int ret=dNum >=0.5? iNum+1:iNum;
       System.out.println(ret);

       //常用的地方求两个数的最大值
       int x1=30;
       int y1=50;
       //x1 y1的最大
       int max=x1>=y1? x1:y1;
       System.out.println(max);

    boolean a=true,b=false,c;
        c=a=b? a:b;
        System.out.println(c);

       /**三元运算符在分页业务逻辑中使用：
        * 需求：给出一共有46条数据，要求每一页最多十条数据，计算一共分多少页？
        * 需求二：
        * 使用if else 计算一共分多少页？
        * */
        int sj=46;
        int ret3=(int)(sj/10);
        int ys=sj-ret3*10;
        int numb=ys>0? ret3+1:ret3;
        System.out.println(numb);

        int sj1=46;
        int ret4=(int)(sj1/10);
        int ys1=sj1-ret4*10;
        if(ys>0){
            System.out.println(ret4+1);
        }else {
            System.out.println(ret4);
        }
        //注意：
        int num5=9800;
        int num6=num5/1000*1000;
        System.out.println(num6); //9000


        /**
         * 运算符的操作优先级：
         * 先乘除后加减 
         * 优先级                              运算符                           结合性                                              
         * 1                                    （）[]                         从左向右
         * 2                             !  = - ~ ++ -- +(正) -(负)            从右向左
         *                                      * / %
         *                                         + -
         * 
         * 
         *                                          ?:
         *最低                                 =  += -= /= %                   从右向左
         *                                       <<= >>=
         * */   
}
}

补充

1.Java的变量命名规则。
普通变量：[驼峰命名+顾名思义+前缀]
1.采用驼峰命名;
2.变量名要尽量简短，顾名思义
3.大小有别，避免同时使用；
3.Java语言中定义标识符的时候需要注意的问题。
Java标识符由数字，字母和下划线（_）,美元符号（$）或人民币符号（￥）组成。java中是区分大小写的，而且还要求首位不能是数字。最重要的是，java关键字不能当做java标识符。

java初级入门，java初级