003.JAVA基础

003.JAVA基础

003.JAVA基础

ref:https://www.bilibili.com/video/BV12J41137hu?p=1&vd_source=0668ce68180b1998d39bd3f7486aad99

笔记来自【狂神说Java】Java零基础学习视频通俗易懂

数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都必须要限定以后才能使用。

JAVA的数据类型分为两大类

基本类型
引用类型

什么是字节

位(bit):是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
字节(byte):是计算机中数据处理的基本单位，习惯上用大写B来表示
1B (byte,字节) = 8bit(位)
字符:是指计算机中使用的字母、数字、字和符号
1bit表示1位
1Byte表示一个字节1B=8b。
1024B=1KB
1024KB=1M1024M=1G.

扩展

import java.math.BigDecimal;

public class Demo2 {
    public static void main(String[] args) {
        //进制 二进制0b 十进制 八进制0 十六进制0x
        int a = 10;
        int b = 010;  //八进制0
        int c = 0x10;   //十六进制0x 0~9 a~f 16
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println("------------------------------------");

        //==================================================================
        //浮点类型 拓展  银行业务怎么表示钱？
        //BigDecimal 数学工具类
        //==================================================================
        //float 有限 离散 舍入误差，大部分数无法精确表示，只能为大约数 接近但不等于
        //double
        float d = 0.1f;
        double e = 0.1;
        System.out.println(d == e); //false

        //少用浮点类型进行比较，最好用BigDecimal来操作
        //最好完全使用浮点类型去比较
        //最好完全使用浮点类型去比较
        //最好完全使用浮点类型去比较
        float d1 = 123123123123f;
        float d2 = d1+1;
        System.out.println(d1 == d2);//true

        //==================================================================
        //字符拓展
        //==================================================================
        System.out.println("==================================================================");
        char c1 = 'c';
        char c2 = '中';

        System.out.println(c1);
        System.out.println(c2);
        //所有的字符本质还是数字 编码 Unicode表(99 = c  20013 = 中)
        System.out.println((int)c1);    //99
        System.out.println((int)c2);    //20013
        System.out.println("==================================================================");
        //因此也可以使用编码来输出文字 格式:u0000 ufff
        System.out.println('\u0067');   //g

        //转义字符
        //  \t 制表符
        //  \n 换行
        System.out.println("hello\tworld");
        System.out.println("hello\nworld");

        System.out.println("==================================================================");
        //涉及创建对象时  堆和栈的理解  对象，内存的理解
        String aa = new String("aa");
        String ab = new String("aa");
        System.out.println(aa == ab);   //false

        String ac = "aa";
        String ad = "aa";
        System.out.println(ac == ad);   //true

        //boolean 布尔值扩展
        boolean flag = true;    //新手
        if(flag == true){}      //老手
        if(flag){}  //Less is More! 代码要精简易读
    }
}

类型转换

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。
```
//低----------------------------->高
byte,short,char-> int -> long-> float -> double
```
运算中，不同类型的数据先转化为同一类型，然后进行运算。
强制类型转换
自动类型转换

public class Demo3 {
    public static void main(String[] args) {

        //byte,short,char-> int -> long-> float -> double
        int a = 128;
        byte b = (byte) a;

        //强制转换 (类型)变量  高--低
        System.out.println(a);  //128
        System.out.println(b);  //-128  Byte类型 MIN_VALUE = -128   MAX_VALUE = 127 内存溢出导致值的变化
        System.out.println("=======================");
        //自动转换 低--高
        int a1 = 128;
        double b1 = a;
        System.out.println(a1);
        System.out.println(b1);

        System.out.println("=======================");
        /*
        注意点:
        1、不能对boolean类型转换
        2、不能把对象类型转换为不相干的类型
        3、在把高容量转换到低容量的时候，强制转换，反之不用
        4、转换的时候,可能遇到内存溢出或者精度问题
         */
        System.out.println((int)22.2);  //22
        System.out.println((int)23.7f); //23

        System.out.println("=======================");
        char c = 'a';
        int c1 = c+1;
        System.out.println(c1); //98
        System.out.println((char)c1);   //b

        //操作数值较大的数时，注意溢出问题
        //jdk7新特性，数字之间可以用下划线分割
        int money = 1_000_000_000;
        System.out.println(money);  //100000000
        int years = 20;
        int total = money * years;
        System.out.println(total);  //-1474836480,计算时候溢出
        long total2 = money * years;  //计算默认结果为int 转换之前问题已经出现

        long total3 = money * (long)years;  //计算时先把一个数转化为long类型
        System.out.println(total3); //20000000000
    }
}

变量常量作用域

变量

变量是什么:就是可以变化的量!
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type varName[=value] [{,varName[=value]}] ;
//数据类型变量名=值;可以使用逗号隔开来声明多个同类型变量。

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

起类名，方法名，定义变量，都应注意程度可读性，方便自己，方便他人

变量作用域

类变量
实例变量
局部变量

public class Demo4 {
    //属性:变量

    //实例变量 从属于对象 如果不进行初始化 该变量值为该类型的默认值
    public String name;
    public int age;
    //boolean 默认值为false
    public boolean flag;
    //除了基本类型，其余默认值都为null

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

    //mian方法
    public static void main(String[] args) {
        //局部变量,必须声明和初始化值
        int a = 1;
        System.out.println(a);

        //变量类型 变量名字 = new 变量类型();
        Demo4 demo1 = new Demo4();
        System.out.println(demo1.name);
        System.out.println(demo1.age);  //0
        System.out.println(demo1.flag); //false

        //类变量 static
        System.out.println(salary); //1000.0
    }
    //其他方法
    public void add(){

    }
}

常量

常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

public class Demo5 {
    //修饰符 不存在先后顺序
    //常量变量名一般都是用大写字母来表示
    final static double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

所有的变量名、方法、类型：见名知意；
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man,GoodMan
方法名：首字母小写和驼峰原则：run(),runRun()

运算符

Java语言支持以下运算符: 优先级 ()

算术运算符：+，-， ，l， %，++，--
赋值运算符：=
关系运算符：>，<，>=，<=，==,!= instanceof
逻辑运算符：&&，|，!
位运算符：&，|，^, ~，>>，<<， >>>(了解! ! ! )
条件运算符：?︰
扩展赋值运算符：+=，-=，*=，/=

package com.operator;

//算术运算符
public class Operator {
    public static void main(String[] args) {
        //算数运算符
        int a = 11;
        int b = 22;
        int c = 35;
        System.out.println(a+b);    //33
        System.out.println(a-b);    //-11
        System.out.println(a*b);    //242
        System.out.println(a/(double)b);    //0.5 当结果有小数出现时 需要强转为double类型
        //取余 也叫模运算
        System.out.println(c%a);    //2  取余   35/11 = 3...2

        System.out.println("=================");
        long a1 = 12312312312312L;
        int a2 = 123;
        short a3 = 12;
        byte a4 = 13;
        System.out.println(a1+a2+a3+a4);    //12312312312460 long
        System.out.println(a2+a3+a4);   //148 int
        System.out.println(a3+a4);  //25 int

        System.out.println("=================");
        //关系运算符
        //关系运算符返回结果：true or false  boolean值
        int b1 = 10;
        int b2 = 15;
        int b3 = 179;
        System.out.println(b1>b2);  //false
        System.out.println(b1<b2);  //true
        System.out.println(b1>=b2); //false
        System.out.println(b1<=b2);  //true
        System.out.println(b1==b2); //false
        System.out.println(b1!=b2); //true
    }
}

package com.operator;

public class Demo1 {
    public static void main(String[] args) {
        // ++ -- 自增 自减
        int a = 3;
        System.out.println(a);  //3
        int b = a++;    //执行这段代码，a先赋值给b，然后再进行自增操作（先赋值，后自增）
        // a = a + 1;   //a++是在赋值后进行
        System.out.println(b);  //3
        //a = a + 1;    //++a是在赋值前进行
        int c = ++a;
        System.out.println(c);  //5

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

位运算

ref:https://www.runoob.com/w3cnote/bit-operation.html

package com.operator;

//位运算符
public class Demo03 {
    public static void main(String[] args) {
        /*
        A = 0011 1100;
        B = 0000 1101;
        ---------------------
        A&B = 0000 1100;
        A|B = 0011 1100;
        A^B = 0011 0001;
        ~B = 1111 0010;

        使用位运算 效率极高
        2*8 2*2*2*2

        <<  各二进位全部左移若干位，高位丢弃，低位补0
        >>  各二进位全部右移若干位，对无符号数，高位补0，有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补0（逻辑右移）
         */
        System.out.println(2<<3);   //16
        System.out.println(9>>2);   //2
    }
}

package com.operator;

//扩展赋值运算符
public class Demo04 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        a+=b;
        // a = a + b;
        System.out.println(a);  //30
        b-=c;
        //b = b - c;
        System.out.println(b);  //-10
        //字符串链接 +  String
        System.out.println(""+a+b); //30-10
        System.out.println(a+b+""); //20    //结果不同是因为代码执行顺序原因导致
    }
}

package com.operator;

//三元运算符 三目运算
public class Demo05 {
    public static void main(String[] args) {
        //x?y:z
        //如果x为true，结果则为y，否则结果为z
        int score = 90;
        System.out.println(score>60?"及格":"不及格");
    }
}

## 包机制(package)

### Java 包(package)

- **为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。**

### 包的作用

- **1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。**
- **2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。**
- **3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。**

**Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。**

**包语句的语法格式为：**

```java
package pkg1[．pkg2[．pkg3…]];

例如,一个Something.java 文件它的内容

package net.java.util;
public class Something{
   ...
}

import 关键字

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

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

import package1[.package2…].(classname|*);

package 的目录结构

类放在包中会有两种主要的结果：

包名成为类名的一部分，正如我们前面讨论的一样。
包名必须与相应的字节码所在的目录结构相吻合。

ref:https://www.runoob.com/java/java-package.html

JavaDoc

package com.base;

/**
 * @author wen
 * @version 1.0
 * @since 1.8
 */
public class Doc01 {
    public String name;

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

    //命令行生成帮助文档 javadoc -encoding UTF-8 -charset UTF-8 Doc01.java

    //学习使用IEDA 生成帮助文档
    //https://blog.csdn.net/mjkkhjl/article/details/113738418?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1-113738418-blog-102531538.pc_relevant_aa2&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1-113738418-blog-102531538.pc_relevant_aa2&utm_relevant_index=1

    //基础部分几乎在以后的开发日常中每天都会使用，打好基础，才能所向披靡!!!
}

posted @ 2022-07-10 17:41 善良de巴斯光年阅读(68) 评论(0) 收藏举报

刷新页面返回顶部

善良de巴斯光年

再小的帆也能远航！

003.JAVA基础

003.JAVA基础

数据类型

强类型语言

JAVA的数据类型分为两大类

什么是字节

扩展

类型转换

变量常量作用域

变量

变量作用域

常量

变量的命名规范

运算符

import 关键字

package 的目录结构

JavaDoc

公告

善良de巴斯光年

再小的帆也能远航！

003.JAVA基础

003.JAVA基础

数据类型

强类型语言

JAVA的数据类型分为两大类

什么是字节

扩展

类型转换

变量 常量 作用域

变量

变量作用域

常量

变量的命名规范

运算符

import 关键字

package 的目录结构

JavaDoc

公告

变量常量作用域