Java 2.0--基础阶段（建立编程思想）

~是小王吖~

已于 2022-07-26 20:18:25 修改

阅读量1.9k

点赞数

CC 4.0 BY-SA版权

分类专栏： Java idea 文章标签： java

于 2021-07-26 15:19:31 首次发布

本文链接：https://blog.csdn.net/Sunblogy/article/details/119110310

Return Java

第一章
- Java了解
第二章
- Java变量
第三章
- 程序控制结构
第四章
- 数组
第五章
- 类与对象
第六章
- 包与封装
第七章
- 继承与多态
第八章
- Object类详解

第一章

Java了解

1.1Java诞生

1、1995 年 sun正式发布Java第一个版本（创始人：gosling）
2、最新版本Java15（使用时期不长）
3、Java现在属于甲骨文公司

1.2Java特点

Java语言是面向对象的(oop)
Java语言是健壮的。 Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证
Java语言是跨平台性的, [即:一个编译好的.class文件可以在多个系统下运行,这种特性称为跨平台性
Java语言是解释型的
解释性语言: javascript,PHP java 编译性语言: c/c++
区别是: 解释性调言,译后的代码,不能宣接被机器执行,需要解得器来执行，编译性语言，编译后的代码,可以直接被机器执行, c/c++

1.3 Java快速入门

在这里插入图片描述
编译过程：
E:\return java>javac Hello.java（javac 一个Java文件）
运行过程：
E:\return java>java Hello（java 你的类）

1. 4 Java中注意事项

1、Java源文件以 .java为扩展名，源文件的基本组成部分是类（class）
2、一个源文件中最多只能有一个public类，其他类可多。编译后，每一个类对应一个 .class
3、如果源文件中包含一个public类，则文件名必须按照该类名命名
4、也可以将main方法写在非public类中，然后指定运行非public类。（java 类名即可）

1.5 转义字符

// 第一个\表示转义第二个\表示输出
//在控制台（dos命令）可以用tab键实现补全

     // \t: 一个制表位。实现对其功能
	System.out.println("北京\t上海\t天津");
	
	// \n:换行
	System.out.println("北京\n上海\n天津");
	
	// \\:输入一个\
	System.out.println("北京\\上海\\天津");
	
	// \": 输出一个"
	System.out.println("我说\"北京上海天津\"");

在这里插入图片描述

      // \r：回车   这个回车不是换行，而是直接跳转到第一个字符处
      System.out.println("北京上海\r天津");

在这里插入图片描述

1.6 注释

单行： //

多行： /* */

文档：
注释的内容可以被jdk提供的工具javadoc所解析。生成一套以网页文件形式体现该程序的说明文档，一般写在类里面

/**

注释内容

内容可以有：
·@author：作者。
·@version：版本。
·@docroot：表示产生文档的根路径。
·@deprecated：不推荐使用的方法。
·@param：方法的参数类型。
·@return：方法的返回类型。
·@see：用于指定参考的内容。
·@exception：抛出的异常。
·@throws：抛出的异常，和exception同义

1.7 Java代码规范

1、选中代码，按 tab 键整体右移
选中代码，按 shift+tab 整体左移
2、类、方法的注释要用javadoc（文档注释）
3、在写代码的时候，源文件要使用utf-8
4、每一行尽量不要超过80
5、次行风格和行尾风格

1.8 DOS命令

进入后默认在c盘
1、换盘方式：盘：
例： d：（进入d盘）
2、创建文件夹： md 文件夹名字
例： md class
3、进入文件夹： cd 文件夹名字或者 cd：某盘|文件夹名字
例： cd class // cd d：|class
4、删除文件夹： rd 文件夹名字
例： rd class 注:当文件夹里面什么都没有时可用
5、删除文件： del 文件名
例; del 1.doc
6、退回上一级文件夹; cd…
7、退回根文件夹; cd/
8、退出dos命令行; exit
9、列出当前目录下的文件和文件夹： dir
10、清屏：cls

1.9 JDK、JRE、JVM 三者关系

在这里插入图片描述

第二章

Java变量

2.1 加号使用

两边都是加号（+）的时候，做加法运算
有一边为字符串时，做拼接运算
System.out.println（“100”+3）输出：1003
System.out.println（100+3）输出：103
System.out.println（“hello”+3+100）输出：hello3100
System.out.println（100+3+“100”）输出：103hello

2.2 数据类型

括号里面代表此数据类型的字节数

2.2.1 整形

byte【字节】 1字节：-128----127 1byte=1B

short【短整型】 2字节：-（2的15次方）—（2的15次方-1）即：
-32768–32767

int【整形】 4字节： -（2的31次方）—（2的31次方-1）即：-2147483648–2147483647
long【长整型】 8字节：-（2的63次方）—（2的63次方-1）

数据类型细节： long类型后面的值要记得加上L long n = 3L； bit最小存储单位 byte基本存储单位 1byte=8bit

2.2.2 浮点

浮点数=符号位+指数位
float：4字节 = 4B
double：8字节 = 8B

浮点型细节：
1、float记得值后面加f
2、十进制形式： 5.12 512…0 .512（相当于0.512 零可以省略
小数点不能省略）
3、科学计数法： 5.12e2 （5.12*10的2次方） 5.12E-2（5.12/10的2次方）
4、在对两个小数进行相等判断的时候，应该是以两个数差值的绝对值在某个精度范围内判断绝对值：
Math.abs(num1-num2)

2.2.3 字符型

‘ ’单引号引着

字符型细节：

  1、‘\’这个不是字符  这是转义字符的标志 例如：‘\t’调节成表位  
  2、在java中，char的本质其实是整形，因为char存入的是Unicode码对应的数值
    例：
     char a = ‘王’；
     system.out.println（（int）a） 
  3、char类型是可以参与运算的，因为本质是整形，在运算的时候会先转换成对应字符再进行计算
    例：
    system.out.println（‘a’+ 10）//等于  107
    这就是先吧‘a’转换成unico码 97 ，再进行与10的加法

字符和码值的对应关系：

    ASCII码（一个字节表示字符，一共128个字符，实际最多表示256个字符）美版
    Unicode码 （两个字节来表示字符  字母和汉字一样，不区分汉字）
    utf-8（大小可变，字母一个字节，汉字三个字节）
    gbk（字母一个字节，汉字两个字节）
    gb2312（也可以表示汉字，gb2312<gbk）

4. 布尔类型：

大部分是1B，有时候是4B

低精度转化到高精度：
char —> int —> long —> float --> double;
byte --> short —> int —> long—> float —> double
例：
int a = ‘a’

2.3基本类型和字符串的转换

2.3.1 基本数据类型转换为字符串：

 语法：将基本数据类型 + “ ”即可
 例：
    int i1 = 100；  String s1 = i1 + “ ”；

2.3.2字符串转成基本数据类型：

语法：通过基本类型的包装类调用parseXX（XX代表基本类型）方法
例：
String s2 = “123”；int num1 = Integer.parseInt（s5）；

2.3.3字符串转换成字符

 意义;把字符串的第一个字符取出来

2.3.4 转换细节

1、在从String类型转换到基本数据类型的时候，要确保能够转换成有效的数据
例：
“123”可以转换成一个整形（int），但是“hello”就不能转换
2、格式不正确就会抛出异常
在这里插入图片描述

2. 4运算符

2.4.1 算术运算符：

（正）

（负）

（加）

（减）

（乘）
/ （除）1
% （取模）

- （自增（前））
  例：a = 2； ++a先加再用
- （自增（后））
  例：a = 2； a++ 先用再加

- （自增（前））
  例：a = 2； - -a先减再用
- （自增（后））
  例：a = 2； a - 先用再减

：字符串相加

注：在取模运算中：
有小数运算的时候，公式： a = a - (int)a / b * b
例：
在这里插入图片描述

2.4.2 运算符优先级

优先级、下表从高到低减小
![在这里插入图片描述](https://img-blog.csdnimg.cn/d562c04118294d61b9f851b234ba2f15.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA562x5rGQ5ZCW,size_ 20,color_FFFFFF,t_70,g_se,x_16)

2.4.3.关系运算符

关系运算符：
= = , ！=

, <
= , < =

==情况，基本数据类型比较的时候，只比较值，引用数据类型时，判断内存地址（堆中）

2.4.4.逻辑运算符

逻辑运算符：
两个（符号） && 短路
单个（符号） & 逻辑
在这里插入图片描述
注：
对于短路与（&&），当第一个条件为假的时候，不判断第二个条件
对于逻辑与（&），当第一个条件为假的时候，仍然要判断第二个条件

短路或和逻辑或一样的：
短路或：第一个真第二个不判断
逻辑或：第一个真第二个还要判断

2.4.5.三元运算符

三元运算符：
语法：条件表达式？表达式1：表达式2
①条件表达式为true，返回表达式1
②条件表达式为false，返回表达式2
表达式1和表达式2要为可以赋给接受变量的类型（或者可以自动转换或者强制转换）
在这里插入图片描述
（错的，double不能够转换给int）
在这里插入图（（错的，double不能够转换给int））片描述

例：
①分开两句实现：
在这里插入图片描述

②一句话实现：

2.4.6.位运算符

在这里插入图片描述

5.4.6.1.按位与：

在这里插入图片描述

2.4.6.2 按位取反：

在这里插入图片描述

注：在补码回原码的时候，可以把首尾的1给定下来不动，中间的数按位取反就可以得到原码（图中蓝色笔记）

2.4.6.3.算术右移 AND 算术左移：

在这里插入图片描述
注：
算术右移本质：原来的数后面/2
算术左移本质：原来的数后面*2
例：

2. 5标识符规则

标识符规则（必须遵守）

标识符规范（建议）
在这里插入图片描述

2. 6关键字和保留字

关键字、保留字不能做标识符

2.6.1 关键字：

在这里插入图片描述

2.6.2 保留字：

在这里插入图片描述

2.7进制

2.7.1 进制：

在这里插入图片描述

2.7.2 进制的图示：

在这里插入图片描述

3 进制的转换

3.1 二进制转十进制：

注：二进制是 0b 开头
在这里插入图片描述

3.2 八进制转十进制：

注：八进制是 0 开头
在这里插入图片描述

3.3十六进制转十进制：

注：十六进制是 0x 开头
在这里插入图片描述

3.4十进制转二进制

注：0b是表示二进制
在这里插入图片描述

3.5十进制转八进制：

注：0是表示八进制
在这里插入图片描述

3.6十进制转十六进制

注：0x是表示十六进制
在这里插入图片描述

3.7二进制转八进制

在这里插入图片描述

3.8二进制转十六进制

在这里插入图片描述

3.9八进制转二进制

在这里插入图片描述

3.10十六进制转二进制

在这里插入图片描述

2.8原码、反码、补码

在这里插入图片描述

第三章

程序控制结构

3.1、顺序控制

程序从上往下逐行执行，中间没有跳转和判断
在这里插入图片描述

3.2、分支控制

3.2.1、单分支

单分支基本语法：
在这里插入图片描述
注：
①、只有一条语句的时候，可以不用 { }（大括号），建议无论是多条还是一条执行语句，都使用 { }（大括号）
②、当if（条件为正的时候）执行大括号里面的执行语句

在这里插入图片描述

3.2.2、双分支

双分支基本语法：
在这里插入图片描述
注：
如果if（表达式为真）则执行代码块1，否则执行代码块2

3.2.3、多分支

多分支基本语法：
在这里插入图片描述
注：哪条条件表达式正确则执行哪条执行语句

多分支对应流程图：
在这里插入图片描述
例：

3.2.4、嵌套分支

在这里插入图片描述

例：

import java.util.Scanner;

public class Singer {
   
   
    public static void main(String[] args) {
   
   
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩及性别：");
        double grade = scanner.nextInt();
        char sex = scanner.next().charAt(0);
        if(grade>8.0){
   
   
            if(sex == '男'){
   
   
                System.out.println("恭喜你进入男子组决赛");
            }else if (sex == '女'){
   
   
                System.out.println("恭喜你进入女子组决赛");
            }
        }else{
   
   
            System.out.println("很遗憾，你淘汰了");
        }
    }
}

3.2.5、switch分支结构

switch分支结构：
在这里插入图片描述
switch语句的流程图：

注：匹配到case常量，执行完语句块后，要是没有break，则不执行下一个case常量，直接执行下一个case常量里面的语句块
例题：

import java.util.Scanner;

public class Switchyuju {
   
   
    public static void main(String[] args) {
   
   
        System.out.println("请输入字符：");
        Scanner scanner = new Scanner(System.in);
        char day =scanner.next().charAt(0);//只要有返回值都可以作为常量
        switch (day){
   
   
            case 'a':
                System.out.println("星期一");
                break;
                case 'b':
                System.out.println("星期二");
                break;
                case 'c':
                System.out.println("星期三");
                break;
            default:
                System.out.println("你输入有错");
        }
    }
}

3.2.6、 switch和if的区别

在这里插入图片描述

3.3、for循环

在这里插入图片描述
for循环执行流程：
注意事项和细节说明：
注：在for循环的时候，先做到化繁为简（从简单到复杂），先死后活（从死变量到活变量）

增强for

for(类型 变量 : 数组/集合){
    代码
}

int [] arr = {1,2,3,4,5,6,7,8,9,10};
for(int a : arr){
    System.out.println(a);//数组中的每一个元素
}

变量是指向后面数组/集合里面的每一个元素

3.4、while循环

在这里插入图片描述
while执行流程分析：
注意事项和细节：
1、循环条件是布尔类型
2、while循环先循环再执行

3.5、do while 循环

说明：
在这里插入图片描述
流程图：

注意事项和细节：
1、循环条件是布尔类型
2、while循环先循环再执行（至少执行一次）

3.6、多重循环

在这里插入图片描述

打印空心金字塔：

3.7、break语句

在这里插入图片描述

3.8、continue语句

在这里插入图片描述

3.9、return语句

在这里插入图片描述

第四章

数组

4.1、一维数组

4.1.1、基本介绍

在这里插入图片描述

4.1.2、动态初始化

动态初始化1、
语法：数据类型 [ ] 数组名 = new 数据类型 [ 大小 ] or 数据类型数组名 [ ] = new 数据类型 [ 大小 ]
例： int [ ] a = new int [5]; or int [ ] a = new int [5]; //创建一个数组数组名为a 长度为5 的int数组

动态初始化2、
①先声明数组：
语法：数据类型 [ ] 数组名 or 数据类型数组名 [ ]
例： int a[ ]; or int[ ] a;
②再创建数组
语法：数组名 = new 数据类型 [ ];
例： a = new int [10];

静态初始化：
语法：数据类型数组名 [ ] = {元素值，元素值，…}；
例： int [a] = {1,2,3,4,5…};//已知数组长度以及元素值的时候使用

4.1.3、注意事项

在这里插入图片描述

4.1.4、数组赋值机制

在这里插入图片描述

4.1.5、数组拷贝

数组拷贝，要求拷贝的数组有独立地址空间：
在这里插入图片描述

4.1.6、数组的添加、扩容

在这里插入图片描述

4.2、二维数组

4.2.1、基本介绍

1、定义形式： int [ ] [ ]

2、理解：二维数组的元素由多个一维数组构成

3、所以一般要进行两次遍历才能获得数组，外层遍历二维数组的元素（也就是一维数组），内存遍历一维数组的元素

4.2.2、动态初始化

1、动态初始化
语法定义：类型[ ] [ ] 数组名 = new 类型 [大小] [大小] //定义时直接new
解读：前一个大小代表二维数组的元素（一维数组）有多少个，后一个大小是每一个一维数组的元素个数。
例：
int [ ] [ ] arr = new int [3] [2]
在这里插入图片描述
2、动态初始化
①先声明：类型数组名 [ ] [ ];
②再定义（开辟空间）数组名 = new 类型 [大小][大小]
③赋值：有默认值，比如int，默认值就是0

3、动态初始化—列数不确定时
①先开展二维数组的空间（其一维数组的个数）
②再开展一维数组的空间，在进行遍历赋值

例：输出这样一个数组
在这里插入图片描述
代码：

public class P179ArrayBuQueDing {
   
   
    public static void main(String[] args) {
   
   
        int arr [] [] ;//声明一个二维数组
        arr = new int[3][];//开展二维数组的空间，定义二维数组有多少个一维数组
        for (int i =0;i< arr.length;i++){
   
   
            arr[i]=new int[i+1];//开展一维数组的空间（定义一维数组可以存放多少个元素）
            for (int j =0;j< arr[i].length;j++){
   
   
                arr[i][j]=j+1;//遍历给其一维数组元素赋值
            }
        }
        for (int i = 0;i< arr.length;i++){
   
   
            for (int j =0;j<arr[i].length;j++){
   
   
                System.out.print(arr[i][j]+"\t");//输出整个二维数组
            }
            System.out.println();
        }

    }
}

4.2.3、静态初始化

语法：
类型[] [] 数组名 = { {值1，值2…},{值1，值2…},{值1，值2…},{值1，值2…}}
使用方法：固定的方法（依次遍历）

实例：
int[ ] [ ] arr={ {1,2,3},{1,5,8},{1}}
注：二维数组的元素必须是一维数组

4.2.4、杨辉三角

打印一个10行的杨辉三角图像：

public class P182YangHuiSanJiao {
   
   
    public static void main(String[] args) {
   
   
        int [][] arr =new int [10][];//定义二维数组（一维数组的个数）
        for (int i =0;i< arr.length;i++){
   
   
            arr[i]=new int[i+1];//定义开展一维数组的空间
            for (int j=0;j<arr[i].length;j++){
   
   
                if (j==0 || j==i)//第一个和最后一个数字为1
                arr[i][j]=1;
                else {
   
   //中间数的取值
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
            }
        }
        System.out.println("====杨辉三角====");
        for (int i=0;i< arr.length;i++){
   
   
            for (int j=0;j<arr[i].length;j++){
   
   
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

在这里插入图片描述

4.3、数组的细节

在这里插入图片描述

4.4、练习题

在这里插入图片描述

代码：

public class P187KuoRongChaRu {
   
   
    public static void main(String[] args) {
   
   
        int[] arr = {
   
   10, 12, 45, 90};
        int[] Newarr = new int[arr.length + 1];//定义新数组长度
        int index = -1, add = 23;//index作为标志，标记插入的位置
        for (int i = 0, j = 0; i < arr.length; i++) {
   
   
            if (add <= arr[i]) {
   
   //判断插入的位置
                index = i;//找到将其下标赋值给index，然后退出
                break;
            }
        }
        if (index == -1){
   
   //如果没有找到，则添加在最后
            index = arr.length;
        }
        for (int i =0,j=0;i< Newarr.length;i++){
   
   
            if (index != i){
   
   //将原来的数组拷贝到新数组，遇到插入位置的时候不拷贝
                Newarr[i]=arr[j];
                j++;
            }else {
   
   
                Newarr[i]=add;
            }
        }
        for (int i =0;i< Newarr.length;i++) {
   
   
            System.out.print(Newarr[i]+"\t");
        }
    }
}

在这里插入图片描述

import java.util.Random;

/**
 * @Author wanghaiyang
 * id 201931101227
 * @date 2021/7/29 11:56
 */
/*随机生成100以内的十个数，找出其最大值下标和最小值下标，将其降序排序，
输出总和，并查询是否含有8这个数字。*/

public class P188SunJiShu {
   
   
    public static void main(String[] args) {
   
   
        int [] arr =new int[10];//定义数组，长度为十
        int sum=0;
        int index2 =-1;//建立索引，判断是否含有8
        Random random =new Random();//随机数生成语法
        for (int i =0;i<10;i++){
   
   
            arr[i]=random.nextInt(100);//生成100以内的随机数
            sum +=arr[i];//求和
            while (arr[i]==8){
   
   //含有8，将其标记下来
                index2 =1;
            }
        }
        System.out.print("随机数组：");
        for (int i =0;i< arr.length;i++) {
   
   
            System.out.print( arr[i]+"\t");
        }//打印随机数数组
        System.out.println("");
        //通过index2的值来判断是否含有8
        if (index2 ==-1){
   
   
            System.out.println("随机数中没有8");
        }else if(index2 ==1){
   
   
            System.out.println("随机数中有8");
        }
        int max =arr[0];
        int maxindex =0;//标记最大值下标
        int min =arr[0];
        int minindex =0;//标记最小值下标
        //最大值最小值下标确定
        for (int i =1;i< arr.length;i++){
   
   
            if (max <=arr[i]){
   
   
                max=arr[i];
                maxindex =i;
            }else if (min>arr[i]){
   
   
                min =arr[i];
                minindex =i;
            }
        }
        System.out.println("最大下标："+maxindex);
        System.out.println("最小下标："+minindex);
        int temp =0;//中间变量，进行元素判断以及调整位置
        for (int j =0;j< arr.length-1;j++) {
   
   
            for (int i = 0; i < arr.length-1-j; i++) {
   
   
                if (arr[i] < arr[i + 1]) {
   
   
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.print("倒序顺序：");
        for (int i =0;i< arr.length;i++) {
   
   
            System.out.print( + arr[i]+"\t");
        }//打印降序数组
        System.out.println("");
        System.out.println("总和为："+sum);
    }
}

4.5、排序

在这里插入图片描述

4.5.1冒泡排序

用中间变量 temp 来置换两个字符的位置。通常使用两重for循环，外层循环长度为数组长度代表循环轮数，内存循环代表每一轮的循环次数。

例题：
将下列无序数组按照从小到大的顺序排序【24、69、87、12、58】
代码：

public class P174maopao {
   
   
    public static void main(String[] args) {
   
   
        int [] arr = {
   
   1,2,3,4,5};
        int temp =0;//中间变量，用于置换字符。
        for (int i =0; i< arr.length-1;i++){
   
   
          for (int j = 0;j< arr.length-1-i;j++){
   
   
            if (arr[j]>arr[j+1]){
   
   
            temp = arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
            }
            else {
   
   
                break;
            }//当一个数组是有序的时候，一次都不用比较，直接输出。
        }
        }
       for (int i =0; i< arr.length;i++){
   
   
           System.out.print(arr[i]+"\t");//  \t制表符
       }
    }
}

4.5.2顺序查找

将要查找的内容与已知数组元素，从第一个一一比较是否相等。

例题：
有一个数列：向红、小王、江仔、啦啦、露露，从键盘输入任意一个名称，判断此数列包不包含这个名称，有则输出其下标，没有则输出：不好意思，没有找到

public class P176ShunXuChaZhao {
   
   
    public static void main(String[] args) {
   
   
        String [] Name ={
   
   "向红","小王","江仔","啦啦","露露"};
        System.out.println("请输入你所要查找的名称：");
        Scanner scanner = new Scanner(System.in);
        String FindName = scanner.next();
        int index = -1;//创建索引
        for (int i =0;i<Name.length;i++){
   
   
            if (FindName.equals(Name[i])){
   
   //字符的比较用equals
                System.out.println("恭喜你，"+FindName+"找到，其下标为："+i);
                index =i;//索引标记找到
            }
        }
        if (index==-1){
   
   //当索引不变时，代表没有找到
            System.out.println("不好意思，没有找到");
        }