java学习笔记

2022/4/12 1:43:11

编程Tag： string Java int 笔记 学习 out system public println

本文主要是介绍java学习笔记，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

标识符

  • 所有的标识符都应该以字母（A-Z或者a-z），美元符号（$）、或者下划线（_）开始
  • 首字符之后可以是字母（A-Z或者a-z），美元符号（$）、或者下划线（_）或数字的任何字符组合
  • 不能使用关键字作为变量的名字或方法名。
  • 标识符是大小写敏感的
  • 合法标识符举例：age、$salary、_value、__1_value
  • 非法标识符举例：123abc、-salary、#abc
  • 可以使用中文命名，但是一般不建议这样使用，也不建议使用拼音，很low

数据类型

强类型语言

  • 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

弱类型语言

Java的数据类型分为两大类

基本类型 (primirive type)

八大基本数据类型

public class Demo02 {
    public static void main(String[] args){
        //整数
        int = 10; //最常用，占4个字节，取值范围：-2147483648 ~ 2147483647
        byte = 20; //占1个字节，取值范围：-128 ~ 127
        short = 30; //占2个字节，取值范围：-32768 ~ 32767
        long = 30L; //占8个字节，取值范围：-9223372036854775808 ~ 9223372036854775807
        
        //小数：浮点数
        float num5 = 50.1F;//float类型要在数字后面加个F，占4个字节
        double num6 = 3.141592653589793238462643; //占8个字节
        
        //字符
        char name = '国'; //占2个字节
        //字符串，String不是关键字，类
        //String name = "秦疆";
        
        //布尔值：是非
        boolean flag = true; //占1位
        //boolean flag = false;
        
    }
}

引用类型 (reference type)

  • 类、接口、数组

什么是字节

  • 位(bit)：是计算机内部数据存储的最小单位，11001100 是一个八位二进制数。

  • 字节(byte)：是计算机中数据处理的基本单位，习惯上用大写 B 来表示

    • 1B(byte,字节) = 8bit(位)

  • 字符：是指计算机中使用的字母、数字、字和符号

1bit表示1位

1byte表示一个字节 1B = 8b。

1024B = 1KB

1024KB = 1M

1024KM = 1G

import java.util.Calendar;
public class Demo03 {
    public static void main(String[] args) {
        // 整数拓展： 进制      二进制  八进制:0   十进制  十六进制:0x

        int i = 10;
        int i2 = 010; // 八进制0
        int i3 = 0x10; // 十六进制0x

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=================================================");
        //====================================================
        // 浮点数拓展     银行业务怎么表示  钱
        //=======================================================
        //float
        //double

        float f = 0.1f;  // 0.1
        double d = 1.0/10; // 0.1

        System.out.println(f==d); //false

        float d1 = 1464513154316156161f;
        float d2 = d1 + 1;

        System.out.println(d1==d2); //true

        //=======================================
        // 字符拓展
        //=======================================
        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 2^6 = 65536

        // U0000 UFFFF

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

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

        System.out.println("Hello\tWorld");
        System.out.println("===============================");
        String sa = new String( original:"Hello World");
        String sb = new String( original:"Hello Wrold");
        System.out.println(sa == sb);

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

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

类型转换

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

低 ——————————————————> 高

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

  • 运算中，不同类型的数据先转化为同一类型，然后进行运算
  • 强类型转换
  • 自动类型转换
public class Demo03 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i; // 内存溢出

        //强制转换     （类型）变量名  高-->低
        //自动转换          低-->高

        System.out.println(i);
        System.out.println(b);

        /*
        * 注意点：
        * 1、不能对布尔值进行转换
        * 2、不能把对象类型转换为不相干的类型
        * 3、在把容量转换到低容量的时候，强制
        * 4、转换的时候可能存在内存溢出，或者精度问题！
        * */
        System.out.println("============================");
        System.out.println((int)23.7);
        System.out.println((int)-45.89F);

        System.out.println("==============================");
        char c = 'a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char) d);

        // 操作比较大的数的时候，注意溢出问题
        // JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years; // -1474836480 , 计算的时候溢出了
        long total2 = money*years; //默认是int，转换之前已经存在问题？

        long total3 = money*years; //先把一个数转换为long
        System.out.println(total3);
    }
}

变量

  • 变量是什么：就是可以变化的量！
  • java是一种强类型语言，每个变量都必须声明其类型。
  • Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。
  • 注意事项：
    • 每个变量都有类型，类型可以是最基本类型，也可以是引用类型。
    • 变量名必须是合法的标识符。
    • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
public class Demo07 {
    public static void main(String[] args) {
        //int a,b,c
        int a=1;
        int b=2;
        int c=3;
        string name = "qinjiang";
        char x = 'x';
        double pi = 3.14;

    }
}

变量的作用域

  • 类变量
  • 实例变量
  • 局部变量
public class Variable{
    static int allClicks = 0;		// 类变量
    String str = "hello world";		// 实例变量
    
    public void method (){
        int i = 0;					// 局部变量
    }
}

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

    // 属性：变量

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

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

        // 局部变量
        int i = 10;
        System.out.println(i);

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

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

    }

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

    }
}

常量

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

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

final 常量名 = 值;
final double PI=3.14;

常量名一般使用大写字符。

public class Demo08 {
    
    // 修饰符，不存在先后顺序
    static final doubel PI = 3.14;
    
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

  • 所有变量、方法、类名：见名知意
  • 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastName
  • 局部变量：首字母小写和驼峰原则
  • 常量：大写字母和下划线:MAX_VALUE
  • 类名：首字母大写和驼峰原则：Man,GoddMan
  • 方法名：首字母小写和驼峰原则：run(),runRun()

运算符

Java语言支持如下运算：运算优先级

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

  • 赋值运算符 =

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

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

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

  • 条件运算符 ? :

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

public class Demo08{
    public static void main(String[] args){
        // 二元运算符
        // Ctrl + D ：复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

    }
}

public class Demo08{
    public static void main(String[] args){
        long a = 123124124124L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d); // Long
        System.out.println(b+c+d);  // int
        System.out.println(c+d);   // int
    }
}

public class Demo08{
    public static void main(String[] args){
        // 关系运算符返回的结果：正确，错误     布尔值

        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(c%a);

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

public class Demo08{
    public static void main(String[] args){
        //++ -- 自增，自减  -元运算符
        int a = 3;

        int b = a++; //执行完 b = a 后在a自增
        int c = ++b; //b自增后再执行 c = b
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        // 自减同理
        // 幂运算 2^3
        double pow = Math.pow(3,2);
        System.out.println(pow);
    }
}

public class Demo08{
    public static void main(String[] args){
        // 与(and)        或(or)       非(取反)
        boolean a = true;
        boolean b = false;

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

        // 短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4); // 短路测试，是否执行了c++,执行了为6，未执行则为5
        System.out.println(d);
        System.out.println(c);
    }
}

public class Demo08{
    public static void main(String[] args){
        /*
          位运算
          A = 0011 1100
          B = 0000 1101
        --------------------------------
        A&B = 0000 1100  # 对应位两个都是1才是1，否则为0
        A|B = 0011 1101  # 有一个为1则为1，否则为0
        A^B = 0011 0001  # 两个相同则为0，否则为1
        ~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
        ……
        */
        System.out.println(2<<3);
    }
}

public class Demo08{
    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);

        // 字符串连接 +
        System.out.println(""+a+b);
        System.out.println(a+b+"");
    }
}

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);

    }
}

包机制

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

相当于文件目录，用于存放文件。

包语句的语法格式为：

package pkg1[.pkg2[.pkg3……]];

一般利用公司域名倒置作为包名：如 公司域名为：www.baidu.com-->包名为：com.baidu.www

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

import package1[.package2……].(classname|*); // *表示所有文件

学习 “阿里巴巴开发手册”

Java Doc

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

参数信息

@author		作者名
@version	版本号	
@since		指明需要最早使用的jdk版本
@param		参数名
@return		返回值
@throws		异常抛出情况

#生成JavaDoc
javadoc -encoding UTF-8 -charset UTF-8 Doc.java

/**
 * @author kuangshen
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    /**
     * author kuangshen
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

百度 “idea生成doc文档”

百度 “jdk帮助文档”

2022年4月12日 p33



这篇关于java学习笔记的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程