Java学习1.1-基础语法

最新推荐文章于 2024-10-06 20:16:20 发布

最佳第六六六人

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量159

点赞数

分类专栏：编程语言_01_Java 文章标签： java

本文链接：https://blog.csdn.net/qq_43523503/article/details/105941145

版权

编程语言_01_Java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

标识符

所有标识符都应该是以大写字母、小写字母、美元符号（$）、下划线（_）开头
首字符后面的可以是大写字母、小写字母、美元符号（$）、下划线（_）、数字的任意组合
标识符的大小写是敏感的
常见关键字有：class public void …

public class Demo01 {
    public static void main(String[] args){
        // 标识符命名可以以大小写字母命名，美元符号$，下划线_开头
        // 也可以以汉字去命名
        String name = "jiwei";
        String 王者荣耀 = "最强王者";
        System.out.println("王者荣耀 name");
    }
}

数据类型

Java是一种强类型的语言，所有变量都需要提前定义才能够使用

1基本的数据类型

数值类型
（1）整数类型：int、byte、short、long
（2）浮点数类型：float、double
（3）字符类型：char
布尔类型
true 或 false

2引用数据类型

类
接口
数组

代码示例：

public class Demo02 {
   public static void main(String[] args) {
       // 八大基本数据类型
       // 整数
       int num1 = 10; // 最常用
       byte num2 = 127; // 取值在（-128，127]之间
       short num3 = 1222; // 取值在（-32768，32767]之间
       long num4 = 199999999; // 取值区间最大
       // 浮点数（两种）
       float num5 = 20.9F; // float类型要在数字后面加F
       double num6 = 20.2222; //double类型不需要加
       // 字符
       char name = 'A'; // 字符是一个字母或者字
       // 字符串，string不是关键字，是一个类
       String name2 = "ASDASD";
       // 布尔值,真假
       boolean flag = true;
       boolean flag2 = false;
   }
}

3数据类型的拓展知识

public class Dome03 {
    public static void main(String[] args) {
        // 整数拓展  进制  二进制0b 十进制 八进制0 十六进制0x
        int i = 10; // 十进制数10
        int i2 = 0b10; // 二进制
        int i3 = 010; // 八进制
        int i4 = 0x10; // 十六进制
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println("=========================");
        // ===============================================================
        // 浮点数拓展 银行业务怎么表示钱？
        // 使用BigDecimal 数学工具类
        // float 表示有限个数 有舍入误差 大约 接近但不等于
        // 最好不使用浮点数进行比较
        // =================================================================
        float f = 0.1f;
        double d = 1.0 / 10;
        System.out.println(f == d); //false

        float f1 = 292929292838383333f;
        float f2 = f1 + 1;
        System.out.println(f1 == f2); // true

        // =========================================================
        // 字符串拓展
        // ==========================================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1); //使用（int）c1去强制转换为整数类型
        System.out.println(c2);
        System.out.println((int)c2); //强制转换
        // 所有的字符本身还是数字
        // 编码的方式是Unicode方式

        // 转义字符
        // \t 制表符 \n 换行

        // 布尔值拓展
        boolean flag = true;
        if (flag==true){}//新手
        if (flag){}//老手
        // 其表示的意思是一样的 Less is more 代码要精简易读
    }
}

4类型转换

Java是强类型语言，所以运算时需要类型转换

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

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

强制类型转换

（类型）+变量名高 --> 低
自动类型转换

低 --> 高不需要加任何转换
注意点：

不能对布尔值进行转换
不能把对象类型转换为不相干类型
大容量到低容量时候，强制转换
在转换过程中可能存在内存溢出，或者精度问题

public class Demo04 {
    public static void main(String[] args) {
        // 强制类型转换 高 --> 低
        int i = 128;
        byte b = (byte)i; //类型转换格式：（类型）+变量名
        System.out.println(i); //输出128 而byte输出是-128
        System.out.println(b); //内存溢出了 因为byte只能表示（-128,128）之间的数

        // 自动类型转换 低 --> 高
        int j = 128;
        double d = j;
        System.out.println(j);
        System.out.println(d);

        // 数据类型转换带来的精度问题
        System.out.println("*****************************************");
        System.out.println((int)12.7); //double类型
        System.out.println((int)1222.33f); //浮点型
        //输出的时候就把小数点后的数值舍去了，精度就降低了

        System.out.println("***********************************************");
        char C = 'a';
        int C2 = C + 1;
        System.out.println(C2);
        System.out.println((char) C2);

        // 操作比较大的数的时候，注意溢出问题
        // JDK新特性，数字之间可以使用下划线分隔，不输出下划线
        System.out.println("******************************");
        int money = 10_0000_0000;
        System.out.println(money);
        int years = 20;
        int total = money * years; //-1474836480，计算的时候溢出了
        long total2 = money  * years; //默认的是int*int，输出也是int所以还是溢出
        long total3 = (long)money *years; //提前转换成long类型
        System.out.println(total3);
    }
}

变量

类型

类变量static
实例变量
局部变量new

public class Demo06 {

    //类变量 static
    static double salary = 1500;


    // 实例变量:从属于对象；如果不自行初始化，这个类型的默认值，数值类型为0 0.0
    // 布尔类型默认是false
    // 其余类型的默认值都是null
    String name;
    int age;

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

        //局部变量，使用前必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型 变量名字 = new Demo06（）；
        Demo06 demo06 = new Demo06();
        System.out.println(demo06.age);
        System.out.println(demo06.name);

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

    }

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

    }
}

格式：

类型+变量名 = 值;

int a = 3;
String name = "jiwei";
char x = "X";
double pi = 3.14;

主义事项：

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

常量

初始化后不会改变的值！

常量一般都使用大写字符

final 常量名 = 值

public class Demo07 {
    //修饰符final不存在先后顺序，也可以写成 final static double PI = 3.14;
    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规则

见名知意
类成员变量：驼峰原则，除了第一个单词以外，后面的单词首字母大写，例如：monthSalary
局部变量：首字母小写和驼峰原则
常量：全部大写字母
类名：首字母大写和驼峰原则
方法名：首字母小写和驼峰原则

运算符

算数运算符 + - * / %取余 ++ –

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //++    --  自增 自减
        int a = 3;

        int b = a++;//执行完这行代码后，先给b赋值，再自增
        //a++   a = a + 1;

        //a++   a = a + 1;
        int c = ++a;//执行完这行代码前，先自增，再给b赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算 2^3   2*2*2 = 8   很多运算，我们会使用一些工具类进行操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}

赋值运算符 =
关系运算符 > < >= <= == != instanceof

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确true 错误false 布尔值
        int a = 10;
        int b = 20;
        int c = 22;
        // 取余，模运算
        System.out.println(c%a);// c/a   22/10=2....2 输出余数2

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}

逻辑运算符 &&与 ||或 !非

package operator;

//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        //与（and）    或（or）   非（取反）
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a&&b));//逻辑与运算：两个变量都为真，结果才为True
        System.out.println("a || b:"+(a||b));//逻辑或运算：两个变量只要有一个为真，结果就为Teue
        System.out.println("!(a && b):"+!(a&&b));//逻辑非运算：如果是真，则变为假；如果为假，则变为真

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}

位运算符

A = 0011 1100
B = 0000 1101
------------------
A&B = 0000 1100    与运算  只要都为1才为1
A|B = 0011 1101    或运算  只要都为0才为0
A^B = 0011 0001    异或运算  只要相同才为0
~B = 1111 0010     非运算   取反

2*8 = 16  2*2*2*2
位移运算 效率极高！！！！
<< 左移   *2
>> 右移   /2

0000 0000       0
0000 0001       1
0000 0010       2
0000 0011       3
0000 0100       4
0000 1000       8
0001 0000       16

条件运算符(必须掌握！！！)

package operator;
//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        // x ? y : z
        //如果x == true，则结果为y，否则结果为z
        int score = 50;
        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
        System.out.println(""+a+b);//输出1020，当字符串“”在前面默认转换为字符串拼接
        
        System.out.println(a+b+"");//输出30， 当字符串“”在后面 前面的还要进行运算
    }
}

包机制

一般利用公司域名倒置作为包名，com.baidu.www

包的导入

Java自带的包，写上关键字直接就给引用了

引入自己写的包

import com.eighteen.base.Demo01;//导入Demo01类
import java.util.Date;
import com.eighteen.base.*//导入这个包内的所有类

JavaDos 生成文档

Java在线文档

Javados命名是用来生成自己的API文档

参数信息：@author 作者名

@version 版本号

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

@param 参数名

@return 返回值情况

@throws 异常抛出情况

第一步 IDEA编辑

package com.eighteen.base;
/**
 * @author jiwei		加在类前面
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    // 属性
    String name;
    
    // 方法
    /**
     *						加在方法前面
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

第二步 Doc命令行输入

C:\Java_course\JavaSE\基础语法\src\com\eighteen\base>javadoc -encoding UTF-8 -charset UTF-8 Doc.java

编译后的文档，显示在原文件夹

最佳第六六六人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录