java学习

MarkDown 标题 三级标题 四级标题 字体

hello,World!

hello,World!

hello,World!

hello,World!

引用

姚文睿学java

分割线

---

---

图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JXWnOjJs-1651326229913)(F:322861.jpg)]

超链接

点击跳转到博客

列表

1. zzw
2. ywr
3. zzw

(-加回车)

• zzw
• ywr
• zzw

表格

名字	性别	生日

代码

(```)

计算机 计算机硬件组成

• CPU
• 主板
• 内存
• 电源，主机箱
• 硬盘
• 显卡
• 鼠标，键盘
• 显示器
• 等…

计算机软件

• 计算机软件可以使用计算机按照事先预定好的顺序完成特定的功能
• 计算机软件按照其功能划分为系统软件和应用软件

系统软件

DOS(Disk Operating System),Windows,Linux,Unix,Mac,Android,iOS

应用软件

WPS，QQ，微信，英雄联盟，绝地求生等

打开CMD的方式 打开方法

• 开始+系统+命令提示符
• win+R 输入cmd
• 资源管理器的地址栏上输入cmd

管理员方式运行

选择以管理员方式运行

常用Dos命令

#盘符切换  磁盘名:
#查看当前目录下的所有文件  dir
#切换目录 cd /d 磁盘名:
#cd ..
#清楚屏幕 cls (clear screen)
#退出终端 exit
#查看电脑的ip ipconfig
#打开计算器  calc       打开画图工具  mspaint     打开记事本  notepad
#ping命令 
    ping www.baidu.com
#文件操作
   md  目录名
   rd  目录名
   cd>  文件名
   del  文件名

C和C++ C

• 贴近硬件，运行极快，效率极高
• 操作系统，编译器，数据库，网络系统等
• 指针和内存管理

C++

• 面向对象
• 兼容C
• 图形领域，游戏等

java特性和优势 特性

1. 简单性
2. 面向对象
3. 可移植性
4. 高性能
5. 分布式
6. 动态性
7. 多线程
8. 安全性
9. 健壮性

java三大版本

javaSE javaME javaEE

JDK,JRE,JVM

Java Development Kit : java开发者工具

Java Runtime Environment: java运行时环境

Java Virtual Machine: java虚拟机

jvm可以用软件实现，也可以用硬件实现

HelloWorld

1. 随便新建一个文件夹，存放代码
2. 新建一个Java文件

​ 1) 文件后缀名为.java

​ 2) hello.java

3. 编写代码

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

4. 编译javac java文件，会生成一个class文件

5. 运行class文件，java class文件

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gpx51m3z-1651326248393)(C:UsersywrdsgAppDataRoamingTyporatypora-user-imagesimage-20220425215620604.png)]

   可能会遇到的情况
   1. 每个单词的大小写不能出现问题，java是大小写敏感的
   2. 尽量使用英文
   3. 文件名 和 类名必须保持一致，并且首字母要大写
   4. 符号使用了中文

Idea写HelloWorld

helloworld

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

关于java类，方法，对象，封装，多态，继承的扩展举例讲解

类：狗这类动物
方法：狗会吠 ，狗会摇尾巴 等等
对象：某一条狗
封装：你只需知道狗会吠就好，无需知道它为什么可以吠，喉咙和舌头怎么运作也不需要知道
继承：狗类继承自犬类，狼类继承自犬类，他们都吃肉，都能跑，这些都是犬类的方法
多态：虽然狼和狗都继承自犬类，但狗类实现了听主人话接口接口，狼类实现了嗷嗷叫接口接口，所以他们就呈现出多态。
https://blog.csdn.net/qq_60750453/article/details/120829332

第一章 Java基础语法 1.1 注释

单行注释

// xxxxxxxxxxxxxxx

多行注释

文档注释

public class HelloWorld {
    public static void main(String[] args) {
        //单行注释
        //输出一个Hello,World!
        System.out.println("Hello,World!");

        //有趣的代码注释
        
       

        
        

        
        
    }
}

1.2 标识符 关键字

• 所有的标识符都应该是以字母（A-Z或者a-z），美元符（$），或者下划线（_）开始
• 首字母之后可以是字母（A-Z或者a-z），美元符（$），或者下划线（_）或数字的任意字符组合
• 不能使用关键字作为变量名或者方法名
• 标识符是大小写敏感的
• 合法标识符举例：age，$salary，_value，__1_value
• 非法标识符举例：123abc，-salary，#abc

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

        //不规范
        String 王者荣耀 = "最强王者";
        System.out.println(王者荣耀);

        //大小写敏感
        String Man = "ywr";
        String man = "ywr";

        String Ahello = "ywr";
        String hello = "ywr";
        String $hello = "ywr";
        String _hello = "ywr";

        String _1 = "ywr";

    }
}

*数据类型

• 强类型语言

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

• Java的数据类型分为两大类

  • 基本类型(primitive type)

    • 数值类型
      • 整数类型：byte(1个字节)，short(2个字节)，int(4个字节)，long(8个字节)
      • 浮点类型：float(4个字节)，double(8个字节)
      • 字符类型：char(2个字节)
    • boolean类型(1位)

    public class Demo02 {
        public static void main(String[] args) {
            //八大基本类型
            
            //整型
            int num1 = 10;//最常用
            byte num2 = 20;
            short num3 = 30;
            long num4 = 30L;//Long类型要在数字后加上L
            
            //小数：浮点数
            float num5 = 50.6f;
            double num6 = 3.141592653589793238462643;
            
            //字符
            char name = '国';
            //字符串,String不是关键字，是类
            //String names = "ywr";
            
            //布尔值：是非
            boolean flag = true;
    //        boolean flag = false;
        }
    }
    

  • 引用类型(reference type)

    • 类
    • 接口
    • 数组

什么是字节

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

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

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

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

• 1bit表示1位

• 1Byte表示一个字节 1B=8b

• 1024B=1KB

• 1024KB=1M

• 1024M=1G

1.3 *拓展 整数拓展

int i1 = 10;
int i2 = 010;//八进制0
int i3 = 0x10;//十六进制0x     0~9 A~F

System.out.println(i1);
System.out.println(i2);
System.out.println(i3);

浮点数拓展

//BigDecimal   数学工具类
//float  有限的，离散的，舍入误差，大约的，接近但不等于
//double

float f = 0.1f;//0.1
double d = 1.0 / 10;//0.1
System.out.println(f == d);//false

float d1 = 232323233f;
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 表：(a = 97  A = 65)  2字节      65536   2的16次方

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

转义字符

System.out.println("HellotWorld");
System.out.println("HellonWorld");

关于String

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
//对象 从内存分析

布尔值拓展

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

1.4 类型转换

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

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

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

运算中，不同类型的数据先转换为同一类型，然后进行运算

• 强制类型转换

  • 高 --> 低

    int i = 128;
    byte b = (byte) i;//内存溢出
    

• 自动类型转化

  • 低 --> 高

    int i2 = 128;
    double b2 = i2;
    

*注意

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

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

        long total3 = money * ((long) years);
        System.out.println(total3);

        //L   l
    }

1.5 变量

• 变量是什么：就是可以变化的量！

• Java是一种强类型语言，每个变量都必须声明其类型

• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

*注意事项

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

变量作用域 类变量

要加关键字static

实例变量

实例变量：从属于对象,如果不初始化值，这个值这个类型的默认值 0 0.0

布尔值默认值false，除了基本类型，其余的默认值都是null

局部变量

写在方法里面的，必须声明和初始化值

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.name);
        System.out.println(demo08.age);
        
        //类变量输出
        System.out.println(salary);
    }

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

    }
}

常量

• 常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值

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

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

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

变量的命名规范

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

1.6 运算符 Java语言支持的运算符

• 算数运算符：+, -, *, /, %(模运算), ++, –
• 赋值运算符： =
• 关系运算符：>, <, >=, <=, ==, !=, instanceof
• 逻辑运算符：&&, ||, !
• 位运算符：&，| , ^, ~, >>, <<, >>>
• 条件运算符 : (？ ：)
• 扩展赋值运算符：+=, -=, *=, /=

一元运算符

• a++：先使用a，再给a+1

• ++a：先给a+1，再使用a

public class Demo04 {
    public static void main(String[] args) {
        //一元运算符
        //++   --   自增，自减
        int a = 3;
        int b = a++;   //先给b赋值，再自增
        //a++  a = a + 1
        System.out.println(a);
        int c = ++a;   //先自增，再给b赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

逻辑运算符

• &&：逻辑与运算：两个变量都为true，结果才为true

  对于&&运算，如果左边为false，则右边不会执行直接输出结果false（短路运算）

• ||：逻辑或运算：两个变量有一个为true，结果为true

• !：如果是true，结果则为false；如果为false，结果则为true

//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        // 与  或   非
        boolean a = true;
        boolean b = false;
        System.out.println("a && b:" + (a && b));//逻辑与运算：两个变量都为true，结果才为true
        System.out.println("(a || b):" + (a || b));//逻辑或运算：两个变量有一个为true，结果为true
        System.out.println("!(a && b):" + !(a && b));//如果是true，结果则为false；如果为false，结果则为true

        //短路运算    对于&&运算，如果左边为false，则右边不会执行直接输出结果false
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);
        System.out.println(c);
        System.out.println(d);
    }
}

位运算符

           A = 0011 1100
           B = 0000 1101
          ----------------
          A&B  0000 1100      如果都为1，结果为1
          A|B  0011 1101      只要有一个1，结果就为1
          A^B  0011 0001      两个相同为0，不同为1
          ~B   1111 0010      取反
         
          2*8怎么运算最快    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

扩展运算符

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

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

面试题：

• 字符串拼接：碰到String类型就会拼接成String类型
  • (“赵紫薇” + a + b)：赵紫薇1020
  • (a + b + “赵紫薇”)：30赵紫薇
• 由于代码是从左往右运行的，所以上面的先运行字符串，后面的所有结果都以字符串拼接，但是下面是先运行a+b，再与字符串进行拼接

三元运算符

public class Demo08 {
    public static void main(String[] args) {
        //三元运算符
        //x ? y : z
        //如果x==true,结果为y，反正结果为z
        //int score = 80;
        int score = 50;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);
    }
}

运算符优先级

• 记忆方法：单目乘除为关系，逻辑三目后赋值
• 单目运算符:一次作用一个变量的运算符，又叫一元运算符
• 单目：单目运算符+ –(正负数) ，++ –，！（逻辑非），~（按位取反）
• 乘除：算数运算符：* / % + - （* / %优先级肯定是大于±的）
• 为：位运算符：~（按位取反）<<(左移) >>(右移)，^（也可以位运算，二进制异或）
• 关系：关系运算符：> < >= <= == !=
• 逻辑：逻辑运算符（除！）&& || & | ^
• 三目：条件运算符A > B ? X : Y
• 后：无意义，仅仅为了凑字数
• 赋值：= += -= *= /= %= |= &= ^=

1.7 包机制

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

• 包语句的语法格式为：

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

• 一般利用公司域名倒置作为包名；

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

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

1.8 JavaDoc

https://www.matools.com/api/java8

• javadoc命令是用来生成自己的API文档
• 参数信息
  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

如何用idea生成JavaDoc文档

可以看这个链接https://blog.csdn.net/weixin_42140580/article/details/89635775

第二章 Java流程控制 2.1 Scanner对象

• Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。

• 基本语法：

  Scanner s = new Scanner(System.in);

• 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前，我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

1. next()

• 1. 一定要读取到有效字符后才可以结束输入
• 2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
• 3. 输入有效字符后，next()方法会将其后面输入的空白作为分隔符或者结束符
• 4. next()不能得到带有空格的字符串

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方法接收:");

        //判断用户有没有输入字符串
        if (scanner.hasNext()) {
            //使用next方法接收
            String str = scanner.next();//程序会等待用户输入完毕
            System.out.println("输出的内容为：" + str);
        }

        //凡是属于IO流的类如果不关闭会一直被占用资源，要养成好习惯用完就关闭
        scanner.close();
    }
}

2. nextLine()

• 1. 以Enter为结束符，也就是说nextLine()方法放回的是输入回车之前的所有字符
• 2. 可以获得空白

public class Demo02 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine方法接收:");

        //判断是否还有输入
        if (scanner.hasNextLine()) {
            //使用nextLine方法接收
            String str = scanner.nextLine();
            System.out.println("输出的内容为：" + str);
        }
        scanner.close();
    }
}

public class Demo03 {
    public static void main(String[] args) {
        //接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入数据：");

        String str = scanner.nextLine();
        
        System.out.println("输出的内容为：" + str);
        scanner.close();
    }
}

3. 判断输出数字的类型

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //从键盘接收数据
        int i = 0;
        float f = 0.1f;

        System.out.println("请输入整数：");

        //如果--那么
        if (scanner.hasNextInt()) {
            i = scanner.nextInt();
            System.out.println("整数数据：" + i);
        } else {
            System.out.println("输入的不是整数数据！");
        }

        System.out.println("请输入小数：");

        //如果--那么
        if (scanner.hasNextFloat()) {
            f = scanner.nextFloat();
            System.out.println("小数数据：" + f);
        } else {
            System.out.println("输入的不是小数数据！");
        }

        scanner.close();
    }
}

4. 输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果

public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果

        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;

        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while (scanner.hasNextDouble()) {
            double x = scanner.nextDouble();
            m = m + 1;
            sum = sum + x;
            System.out.println("你输入了第" + m + "个数据，总和sum = " + sum);
        }

        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值为" + (sum / m));

        scanner.close();
    }
}

2.2 顺序结构