Java基础必学

最新推荐文章于 2024-08-28 23:57:47 发布

锐雯.

最新推荐文章于 2024-08-28 23:57:47 发布

阅读量224

点赞数

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_56073526/article/details/125035881

版权

一、Java框架

二、Java程序的运行机制

解释型
编译型

三、基础内容

学会创建HelloWorld
掌握基本的windows相关的Dos命令
注释
关键词
数据类型
字节
类型转换
变量
命名原则
运算符
运算符优先级

1.学会创建HelloWorld

新建一个java文件，存放代码

文件后缀名为.java
Hello.java
注意：系统可能没有显示文件后缀名，我们需要手动打开

public class HelloWorld{
    public static void main(String[] args){
              System.out.printIn("Hello,World!");
   }
}

编译javac java文件，运行class文件

注意：

1.每个单词的大小写不能出现问题，java是大小写敏感的

2.尽量使用英文

3.文件名与类名必须保持一致，并且首字母大写

4.符号使用了中文

2.掌握基本的windows相关的Dos命令

1.Dos命令在哪里在哪里编写？

在Dos命令窗口当中编写Dos命令

2.Dos命令窗口如何打开？

win+R/开始菜单--->运行 ---->输入cmd--->回车

3.常见的Dos命令？

--exit:退出当前Dos窗口

--cls 清屏

--dir 列出当前子目录/所有子文件

--cd 要进入的路径改变目录

4.路径包括绝对路径和相对路径

绝对路径：表示该路径从某个磁盘的盘符下作为出发点的路径

相对路径：表示该路径从当前所在的路径下作为出发点的路径

假设当前所在的路径是C:\Users\16541>，那么在此时输入cd Desktop，Desktop就是一个相对路径，从当前所在的C:\Users\16541>这个路径作为出发点，开始找 Desktop

假设cd C:\Users\16541>，C:\Users\16541>就是一个绝对路径

--cd..回到上级目录

--cd\ 直接回到根目录

c: 切换盘 d: e: f:

5.Java语言特性

*简单性

*面向对象：Java是纯面向对象的，更符合人的思维模式，更容易理解

*可移植性：Java程序可以做到一次编译，到处运行，可以在windows操作系统上运行，不做任何修改，同样的Java程序可以直接放到Linux操作系统上运行，也叫做跨平台.windows操作系统内核和Linux操作系统的内核肯定不同，他们这两个操作系统执行指令的方式也是不一样的。

JDK工具包

结论：显然Java程序不能直接和操作系统打交道。因为Java程序只有一份，操作系统执行原理不同。Java程序运行在一台虚拟的计算机当中，这个虚拟的计算机叫做Java虚拟机，简称JVM。Java虚拟机在和底层的操作系统打交道。

多线程

*健壮性：和自动垃圾回收机制有关，自动垃圾回收机制简称GC机制

Java语言运行过程中产生的垃圾是自动回收的，不需要程序员关心

*安全性

3.注释

注释不会被执行，是给我们写代码的人看的，书写注释是一个非常好的习惯，平时写代码一定要注意规范。

4.关键词

5.数据类型

八大数据类型

public class Demo1 {
    public static void main(String[] args) {
        //八大基本数据类型
        //整数
        int num1 =10;
        byte bum2 =20;
        short num3 =30;
        long num4 = 30L;//Long类型要在数字后面加个L
        //小数：浮点数
        float num5 =50.1F;
        double num6 =3.1415926;
        //字符
        char name = '雯';
        //字符串，String不是关键字，是类
        // String namea ="锐雯"

        //布尔值
        boolean flag =true;
       // boolean flag =false;
    }
}

6.字节

什么是字节？

7.类型转换

package com.ruiwen.base;

public class Demo2 {
    public static void main(String[] args) {
        int i=128;
        double b=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.99);

        System.out.println("===========");
        char c='a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char)d);//类型强转
    }
}

package com.ruiwen.base;

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

8.变量

package com.ruiwen.base;

public class Demo5 {
    //属性：变量
    static  double salary = 2500;
    //实例变量：从属于对象；如果不自行初始化，这个类型的默认值 0000
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null；
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i=10;
        System.out.println(i);
        //变量类型 变量名字
      Demo5 demo5 = new Demo5();
      System.out.println(demo5.age);
      System.out.println(demo5.name);
       //类变量 static
        System.out.println(salary);
    }
    //其他方法
    public  void  add(){
        System.out.println();
    }
}

常量

package com.ruiwen.base;

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

9.命名规则

10.运算符

package com.ruiwen.operator;

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

    }
}

package com.ruiwen.operator;

public class Demo2 {
    public static void main(String[] args) {
        long a = 123123123123L;
        int b =123;
        short c = 10;//-32768-32767
        byte d =8;//-128-127

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

package com.ruiwen.operator;

public class Demo3 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误  布尔值
        int a = 6;
        int b = 3;
        int c = 21;
        System.out.println(a%b);//取余，模运算
         System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(a^b);

    }
}

package com.ruiwen.operator;
public class Demo4 {
    public static void main(String[] args) {
        //++ -- 自加，自减  一元运算符
        int a=3;
        int b = a++;//执行这行代码后，先给b赋值，再自增
        //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(3,2);
        System.out.println(pow);

    }
}

package com.ruiwen.operator;
  //逻辑运算符
public class Demo5 {
      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));//逻辑或运算，两个变量有一个为真，则结果才为true
          System.out.println("!(a&&b):"+!(a&&b));//如果是真，则变为假，如果是假则变为真
          //短路运算第一个为假的，后面不需要计算
          int c = 5;
          boolean d = (c<4)&&(c++<4);
          System.out.println(d);
          System.out.println(c);
          //以上就是短路运算.
      }
}

package com.ruiwen.operator;

public class Demo6 {
    public static void main(String[] args) {
        /*
          A =0011 1100
          B =0000 1101
          A&B = 0000 1100  //有0则0
          A|B = 0011 1101   有1则1
          A^B = 0011 0001 异或运算
          ~B = 1111 0010
          <<  >>左移和右移 左移相当于*2   右移相当于/2
         */
        System.out.println(2<<3);
    }
}

package com.ruiwen.operator;

public class Demo7 {
    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);
        System.out.println(a+b+"");
    }
}

11.运算符优先级

3 + 4 * 5 > (5 * (2 + 4) - 10)&& 8 - 4>5

圆括号的优先级最高

单目乘除为关系，逻辑三目后赋值。

单目：单目运算符+ –(负数) ++ -- 等

乘除：算数单目运算符* / % + -

为：位移单目运算符>

关系：关系单目运算符> < >=

逻辑：逻辑单目运算符&& || & | ^

三目：三目单目运算符A > B ? X : Y

后：无意义，仅仅为了凑字数

赋值：赋值=