日常学Java的笔记

Markdown学习
计算机硬件
- 计算机硬件组成
  - CPU 内存(Memory) 主板（Motherboard）
- 冯诺依曼体系
快捷键
Java特性和优势
1.Java程序运行机制
2.Java基础语法
3.类型转化-优先级
- 注意点溢出转换问题
4.变量
运算符

Markdown学习

标题：

二级标题

三级标题

图片

超链接

点击跳转

列表

1.有序

A无序
B

表格

代码

tab键上面的三个点

计算机硬件

计算机硬件组成

CPU 内存(Memory) 主板（Motherboard）

冯诺依曼体系

快捷键

关闭当前窗口 Alt+F4
永久删除 shift+delete
打开我的电脑 win+E
打开任务管理器 Ctrl+shift+ESC

DOS命令

打开cmd的方式

win + r
开始+系统+命令提示符
1. 在任意的文件夹下面，shift+鼠标右键，在此处打开命令行窗口
资源管理器的地址栏前面加上cmd

常用的DOS命令

# 盘符切换 d: 表示进入D盘
# 查看目录下所有文件 dir
#切换目录 cd /d
cd.. 返回上一级
清理屏幕 cls
退出终端 exit
查看IP  ipconfig
打开计算器  calc
打开画图  mspaint
打开记事本  notepad
# ping 命令
    ping www.baidu.com
#	文件操作
    md 目录名（创建目录）
    rd 目录名（删除目录）
    cd> 文件名（创建文件）
    del 文件名（删除文件）

计算机语言发展史

第三代语言--1972c语言--面向过程，1995-Java--面向对象

1972年C诞生

贴近硬件，运行极快，效率极高

Java特性和优势

简单性
面向对象
可移植性--write once run anywhere
高能性
分布式
动态性
多线程
安全性
健壮性
思考--Java为什么能成功

JAVA 三大版本

JDK、JRE、JVM

JDK：Java Development Kit

JRE：Java Runtime Environment

JVM：Java Virtual Machine

卸载JDK

删除Java的安装目录
删除JAVA_HOME
删除path下关于Java的目录
Java -version

安装JDK

百度搜索JDK8，找到下载地址
同意协议，下载电脑对应的版本
双击安装JDK
记住安装的路径
配置环境变量
1. 我的电脑-->右键-->属性
2. 环境变量-->JAVA_HOME
3. 配置path变量-->%JAVA_HOME%\bin 和%JAVA_HOME%\jre\bin
测试JDK是否安装成功
1. 打开cmd
2. java -version

1.Java程序运行机制

1.编译型

2.解释型

3程序运行机制

源程序（*.java文件)

Java 编译器

字节码（*.class文件）-->类装载器-->字节码校验器 -->解释器-->>操作系统平台

2.Java基础语法

行注释，idea中注释的颜色-->File--settings--Editor--Java--Comments

单行注释
多行注释
文档注释

面试拓展

整数拓展--进制

二进制 0b
十进制
八进制0
十六进制0x

 		int i = 10;
        int i1 = 010;//八进制0
        int i2 = 0x10;//十六进制0x  0-9  A-F
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println("===============");
结果--
10
8
16

浮点数拓展

  		//浮点数拓展? 银行业务怎么表示？钱
        //BigDecimal  学术工具类
        //===========================
        //float  有限 离散  舍入误差  大约 接近单不等于
        //double
        //最好完全使用浮点数进行比较
        //最好完全使用浮点数进行比较
        //最好完全使用浮点数进行比较
        float d1 = 0.1f;
        double d2 = 0.1;
        System.out.println(d1 == d2);//false

        float d3 = 3235346246326f;
        double d4 = d3 + 1;
        System.out.println(d3==d4);//true

字符拓展

		System.out.println("===============");
        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 Excel 2 16 = 65536
        //U0000  UFFFF
        char c3 = '\u0061';
        System.out.println(c3);//a

        //转义字符
        // \t  制表符
        // \n   换行
        System.out.println("Hello\tWorld!");
        System.out.println("Hello\nWorld!");
        System.out.println("=====================");

        String sa = new String("hello,world");
        String sb = new String("hello,world");
        System.out.println(sa==sb);//false

        String sc = "hello,world";
        String sd = "hello,world";
        System.out.println(sc==sd);//true
        //对象，从内从分析

输出结果：
    A
65
中
20013
a
Hello	World!
Hello
World!

布尔值拓展

		boolean flag = true;
        if (flag==true){}//新手
        if (flag){}//老手
        //Less is more 代码要精简易读

3.类型转化-优先级

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

运算中，不同类型的数据先转化为同一类型，然后进行运算。
强制类型转换
自动类型转换

public class Demo04 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;//内存溢出,Byte -128 -  127
        //强制转换  (类型)变量名   高--低
        System.out.println(i);//128
        System.out.println(b); //-128
        //自动转换          低--高
        double d = i;//128.0 没有问题
        System.out.println(d);//128.0

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

        System.out.println("==========");
        char c ='a';
        int t = c+1;
        System.out.println(t);//98
        System.out.println((char)t);//b
    }
}
结果：
128
-128
128.0
==========
23
-23
==========
98
b

注意点溢出转换问题

public class Demo05 {
    public static void main(String[] args) {
        //操作比较大的数的时候,注意溢出问题
        //JDK7新特性,数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;
        System.out.println(total);//-1474836480,计算的时候溢出了
        long total2 = money*years;
        System.out.println(total2);//-1474836480,默认是int,转换之前已经出现问题了

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

        //小写的l容易看成1，所以为了规范 用大写的L
    }
}
结果：
-1474836480
-1474836480
20000000000

4.变量

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

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

作用域

类变量--写在类里的
实例变量--写在类中间
局部变量--写在方法中的

public class Demo07 {
    //类变量   static 从属于类Demo07,与之一起出来一起消失
    static double salary = 3333;
    //属性：变量

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

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

        //局部变量；必须声明和初始化值
        int i = 10 ;
        System.out.println(i);
        //变量类型  变量名字 = new Demo07();
        Demo07 demo07 = new Demo07();
        System.out.println(demo07.age);//0
        System.out.println(demo07.name);//null
        System.out.println(salary);
    }
    //其他方法
    public void add(){

    }
}

常量

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

	public class Demo08 {
    //修饰符，不存在先后顺序，变量类型前都是修饰符；（常量的定义）
     static final  double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

常量名一般使用大写字符

变量的命名规范

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

运算符

算数运算符

 		//二元运算符
        //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((double) a/b);//除出来有小数要先强转一下

赋值运算符

 		long a = 12354534346L;
        int b = 133;
        short c = 11;
        byte d = 3;
        System.out.println(a+b+c+d);//long
        System.out.println(b+c+d);//Int
        System.out.println(c+d);//Int
结果：
    12354534493
    147
    14

关系运算符

 		//关系运算符返回的结果：正确,错误,     布尔值
        int a = 10;
        int b = 20;
        int c = 12;
        //取余,模运算
        System.out.println(c%a);//2
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
结果：
    2
    false
    true
    false
    true

		int a = 3;
        int b = a++;//执行完这段代码后,先给b复制,再自增
        //a = a + 1;
        System.out.println(a);
        //a = a + 1;
        int c = ++a;//执行完这行代码前,先自增,再给c赋值
        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5

        //幂运算 2^3,很多运算我们会采用一些工具类来操作
        double pow = Math.pow(2,3);
        System.out.println(pow);
结果：
    4
    5
    3
    5
    8.0

逻辑运算符

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

        //短路运算
        int c = 5;
        boolean d =(c<4) && (c++<4) ;//前面的运算为假,就不会继续往下走了
        System.out.println(c);//5
        System.out.println(d);
        /*boolean e = (c>4)&&(c++<4);
        System.out.println(c);
        System.out.println(e);
        boolean f = (++c<4);
        System.out.println(c);*/
结果：
    a && b:false
    a || b:true
    !(a && b):true
    5
    false

位运算

 /*位运算
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100//与，都为1则为1 否则为0
        A|B = 0011 1101//或， 有1为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);//16

拓展赋值运算符

		int a = 10;
        int b = 20;

        a+=b;
        a-=b;
        System.out.println(a);
        //面试题
        //字符串连接符    +   , String
        System.out.println(""+a+b);//1020 前面是个字符串类型就会给后面的都转换为字符串类型

        System.out.println(a+b+"");//30
结果：
    10
    1020
    30

条件运算符

//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        // x ? y : z
        //如果x为真则返回y,否则返回z
        int score = 50;
        String s = score<60 ? "不及格" : "及格";
        System.out.println(s);
    }
}
---不及格

运算符的优先级

posted @ 2022-01-07 11:01 tryAgainCs 阅读(55) 评论(0) 编辑收藏举报

刷新页面返回顶部

再试一次Again