java学习笔记

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量159 收藏
点赞数 6
分类专栏： java 文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ssp0804/article/details/134314304
版权

Java

文章目录

1_下载和安装java环境

1.1 JDK+Idea
  • 下载:
    • 打开浏览器:在地址栏中输入doc.codeboy.com
    • 找到常用下载
    • Windows版
    • mac版
  • 安装:
    • 安装的路径中绝对不能包含中文

2_开发步骤

  1. 新建java项目/工程(project)
  2. 新建java包(package)
  3. 新建java类(class)

3_idea规范

  1. 严格区分大小写
  2. 所有符号必须是英文模式
  3. 每句话必须以分号结尾

4_ java

4.1 Java的编译运行过程
  • 程序员编写的Java源文件(.java)首先要经过编译，生成字节码文件(.class)；
  • Java程序的运行需要JVM的支持，JVM是安装在操作系统中的软件（JAVA虚拟机），为字节码文件运行提供环境；
  • **编译期：**JAVA源文件(.java文件)👉编译👉JAVA字节码（.class文件）；
  • **运行期：**启动JVM👉加载.class文件👉运行.class文件；
4.2 Java跨平台特性
  • 特性：跨平台，一次编译到处运行
4.3 JVM
  • JVM - Java Virtual Machines （Java虚拟机）
  • 作用：加载.class并运行.class
4.4 JRE(运行的最小环境)
  • JRE - Java Runtime Environment (Java运行环境）
  • JRE中除了包含JVM以外，还包含了运行java程序必须的环境
  • JRE = JVM + java系统类库（小零件）
4.5 JDK(开发的最小环境)
  • JDK - Java Development Kit (Java开发工具包）
  • JDK中除了包含JRE以外，还包含了开发JAVA程序必须的命令工具
  • JDK = JRE + 编译、运行等命令工具
4.6 Idea
  • Idea是目前最主流的IDE(集成开发环境)开发环境
  • 是专为程序员提供的具备强大功能的图形界面软件，目前Idea是业界公认最好的Java IDE；
4.7 Git
  • Git是一个开源分布式版本控制系统，是目前世界上最流行的版本控制系统，通过Git可以非常有效、高速的处理从很小到非常大的项目版本管理

5_变量

5.1 变量的属性

  1. 变量是存储数据的"盒子";

  2. 变量具有复用性:一次定义多次使用;

  3. 变量具有可变性:随时随地,依需可变;

  4. 变量的声明/变量的初始化/变量的访问/变量的命名

    1. 变量的声明,需要包含两部分:数据类型和变量名;

    2. 变量的初始化就是第一次给某个变量赋值;

      1. 可以先声明后赋值;
      int a;
a = 250;
      1. 也可以声明的同时进行赋值 int a = 250;;

    3. 对变量的访问就是对其所存数据的访问;

      1. println()输出时若不加双引号,则为变量;
      2. 变量在访问之前,必须声明并初始化;

    4. 变量的命名必须符合Java标识符的规则

      1. 规定:
        • 只能包含字母/数字/_/和$符,并且不能以数字开头
        • 严格区分大小写
        • 不能使用java关键字(java语言规定好的,有特殊意义的符号)
      1. 建议:
        • 绝对杜绝使用拼音作为变量名!!!(很low,而且过不去试用期)
        • 允许中文命名,但不建议,建议"英文的见名知意"/“小驼峰命名法”
        • **小驼峰命名法:**除了第一个单词是小写,其他单词的首字母都是大写
        • 大驼峰命名法:所有单词都是大写,也叫做"派斯卡命名法"

  5. 变量(数据)存储在内存中,内存是有大小的

  6. 变量到底占用多大内存,是由他的数据类型控制的

5.2 变量常用的类型

  1. int:整型,占4个字节,范围是正负21个多亿

    1. 只能用来装整数

    2. 整数直接量默认为int类型:直接写出来的整数,默认都是int型,但不能超范围,若超过范围则编译错误

    3. 两个整数相除,结果还是证书,小数位无条件舍弃**(不会四舍五入)**

      System.out.println(5/2)  //2
System.out.println(2/5)  //0
System.out.println(5.0/2)//2.5  如果一定要有小数则在运算时则一定要有小数

    4. 运算时若超出范围,则发生溢出

      int d = 2147483647;    //int的最大值
d = d+1;
System.out.println(d); //-2147483648(int的最小值),发生溢出了

    5. 补充:

      • byte范围是-128到127之间
      • short范围是-32768到32767之间

  2. long:长整型,占8个字节只能用来装整数,范围比int型要大,正负900多个亿

    • 若想表示长整型,需在数字后加L或l,建议写L
    • 多种数据类型进行运算时,自动转入范围大的类型

  3. double:浮点型,只能装小数

    • 直接写出来的小数,默认为double型,若像表示float,须在数字后加F或f
    • double和float类型的数据在运算时,有可能会发生舍入误差

  4. boolean:布尔型,占1个字节

    • 只能储存true(对/真)或false(错/假)

  5. char:字符型,占用2个字节

    1. 类型特点

      1. 字符型直接量需要放在单引号中,只能有一个
      2. 采用Unicode编码格式
        • 万国码/统一码/通用码,为世界级通用的字符集Java中的char采用的是其中最常用的子集
        • Unincode的特点:一个字符对应一个码
        • ASCII码:**‘a’ 的码 97 , ‘A’ 的码 65 , '0’的码是48 **//需要背下来
      3. 特殊符号需要通过 \ 来转义
      char c9 = ''' //编译错误
char c9 = '\''//正确	输出'
--------------------------------------
char c9 = '\' //编译错误
char c9 = '\\'//正确  输出\

  6. string:字符串型

    • 字符串使用需要在双引号中""
    • 长度没有限制(0到无限个)
5.3 类型间转换

  1. 两种转换方式

    • 自动类型转换/隐式类型转换:从小类型到大类型
    • 强制类型转换:从大类型到小类型

  2. 基本数据类型由小到大依次为:

    • byte < short < int < long < float < double
    • char比int小所以chat可以转成int(char本质上是数字)

  3. 转换的方法

    语法:(要转换成为的数据类型)变量

    int a = 5;
long b = a; //自动类型转换
int c = b; //编译错误,大到小必须强制转换
int c = (int)b;//强制类型转换 (要转换成为的数据类型)变量

  4. 两种特殊情况

    1. 强转溢出

      long f = 10000000000L;
int g = (int)f;
System.out.println(g); //溢出了,强转有可能发生溢出

    2. 强转丢精度

      double h = 25.987;
int i = (int)h;
System.out.println(i); //25,强转有可能丢失精度

  5. 两点规则

    1. 证书直接两可以直接赋值给byte / short / char,但不能超出范围

    2. byte / short / char型数据参与运算时,先一律自动转换为int再运算

      byte b1 = 5;
byte b2 = 6;
byte b3 = b1+b2;         //编译错误,b1/b2被转为int型,结果是int型不能赋值给byte
byte b3 = (byte)b1+b2;   //编译错误,强转优先级高,先强转再运算,最后结果还是int型
byte b3 = (byte)(b1+b2); //想要先运算再强转就先把要运算的用括号括起来

6_运算符

6.1 算数运算符
  • “+” (加法)
  • “-” (减法)
  • “*” (乘法)
  • “/” (除法)
  • “%” (取余数)
    • 商之后剩下的数即是余数，余数为0即为整除
  • “++/–” (自加1/自减1)
    • 单独使用时,直接设置为a自增/自减1
    • ++/-- 可以写在变量前也可以写在变量后（a++/–a）
    • 只要在同一行内有任何不属于++/–的代码则属于被使用
      • 被使用时++/–放在前则++a/–a的值为a+1/a-1
      • 被使用时++/–放在后则a++/a–的值为a
      • 之后对a进行自增1或自减1
6.2 关系运算符(boolean)
  1. 关系运算的结果为Boolean型,关系成立则为true,关系不成立则为false
  2. 常用的关系运算符
    • </> (小于/大于)
    • == (等于)
    • <= / >=(小于等于/大于等于)
    • !=(不等于)
6.3 逻辑运算符(boolean)

  1. 逻辑运算符常常用于多条件运算

  2. 逻辑运算是建立在关系运算的基础之上的

  3. 逻辑运算的结果也是boolean型

  4. 常用的逻辑运算符:

    • “&&” :逻辑与(并且):两边都为真则为真,见false则false

      能毕业吗?falsefalsefalsetrue
      1.考试及格吗truefalsefalsetrue
      并且
      2.出勤率够80%吗falsetruefalsetrue
      • 逻辑与&&在实际业务当中经常要表述在什么与什么之间**(包括首尾两数)**
      • &&:短路与(并且),两边都为真则为真,见false则false,当第1个条件为false时,则发生短路(后面的不执行了)

    • “||” :逻辑或(或者):有真则为真,见true则true

      能结帐吗?truetruetruefalse
      1.有现金吗?truefalsetruefalse
      或者
      2.有微信吗?falsetruetruefalse
      • 逻辑或||在实际业务中进场要表述不在什么与什么之间(不包括首尾)
      • ||:短路或(或者),有真则为真,见true则true当第1个条件为true时,则方式短路(后面的不执行了)

    • !:逻辑非(取反),非真则假,非假则真

      !falsetrue
      下雨了truefalse
      • 在Java中非!的优先级最高
      int a = 5;
int b = 10;
boolean b2 = !a<b; //编译错误,因为在Java中!的运算优先级最高,所以先运算!a了所以编译错误
boolean b2 = !(a<b);//需要用小括号括起来先进行运算因为!的优先级高于小于号
System.out.println(b2); //a<b的结果为true 所以b2的值为false

    • &&短路与

    • ||短路或

    • &与

    • |或

6.4 赋值运算符

  1. 赋值运算符是用于给变量赋值的运算符

  2. 简单赋值运算符

    • “=”

  3. 拓展赋值运算符

    • “+=” “-=” “*=” “/=” “%=”
    • 拓展赋值运算符自带强转功能,依据赋值的变量数据类型进行强转
    int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
------------------------------------
a *= 2;  //相当于a=(int)(a*2)
System.out.println(a); //30
------------------------------------
a /= 6;	 //相当于a=(int)(a/6)
System.out.println(a); //5
6.5 连接运算符

  1. “+” (加号)

  2. 若两边为数字,则做加法运算

  3. 若两边出现在了字符串**(一串字符,放在双引号中,长度没有限制)**,则做字符串连接

  4. 凡是写死的都写在引号里面,凡是可以改变的都写在引号外面

  5. 任何类型的数据与字符串链接,最终的结果都是字符串类型

    System.out.println(10+20+""+30); // 结果是3030----------String
System.out.println(10+""+20+30); // 结果是102030--------String
System.out.println(10+20+30+""); // 结果是60------------String
6.6 条件运算符

  1. 条件运算符,也叫三目运算符

  2. 语法: boolean ? 数1 : 数2

  3. 执行过程:整个条件运算是有值的,它的值要么是表达式1的值,要么是表达式2的值,如果Boolean的结果是true则执行过程走表达式1,若Boolean的结果为false则执行过程走表达式2

    int num1 = 5;
int flag1 = num1>0?1:-1;
System.out.println(flag1); //1

int num2 = -5;
int flag2 = num2>0?1:-1;
System.out.println(flag2); //-1

7_程序结构

  • 任何复杂的程序逻辑,都可以通过三种结构来实现:顺序结构/分支结构/循环结构
7.1 顺序结构
  • 从上往下逐行执行,每句必走
7.2 分支结构
  • 有条件的执行某语句一次,并非每句必走

  1. if结构:

    1. 语法:

      if(boolean){
    语句块------------------基于条件执行的语句
}

    2. 执行过程:

      1. 判断boolean的值
      2. 若为true,则执行语句块(整个结束)
      3. 若为false,则直接结束

    3. 案例

      double price = 500;//消费金额
if(price>=500){
    price *= 0.8; //满500打8折
}
System.out.println(price);

  2. if…else结构:2条路

    1. 语法:

      if(boolean){
    语句块1
}else{		//语句块1和语句块2,有可能同时执行吗?--------不可能
    语句块2  //语句块1和语句块2,有可能同时都不执行吗?-----不可能
}

    2. 执行过程:

      1. 判断boolean的值
      2. 若为true,则执行语句块1(整个结束)
      3. 若为false,则执行语句块2(整个结束)

    3. 说明:语句块1和语句块2,必走其中之一👉解决问题的场景就是2选1

  3. if…else if结构:多条路

    1. 语法:注意最后的else非必要语句!!!

      if(boolean-1){
    语句块1
}else if(boolean-2){
    语句块2
}else if(boolean-3){
    语句块3
}else if(boolean-4){
    语句块4
}else{
    语句块5
}

    2. 执行过程:

      1. 判断boolean-1
      2. 若为true,则执行语句块1(整个结束)
      3. 若为false,则判断boolean-2
      4. 若为true,则执行语句块2(整个结束)
      5. 若为false,则判断boolean-3
      6. 若为true,则执行语句块3(整个结束)
      7. 若为false,则判断boolean-4
      8. 若为true,则执行语句块4(整个结束)
      9. 若为false,则执行语句块5(else非必要语句!)

    3. 案例:

      //满2000打5折，满1000不满2000打7折，满500不满1000打8折，不满500打9折
        Scanner scanner = new Scanner(System.in);
        double price = scanner.nextDouble();
        if (price<0){
            System.out.println("价格不合法,请重新输入");
        }else if (price>=2000){
            price *= 0.5;
        }else if (price>=1000){
            price *= 0.7;
        }else if (price>=500){
            price *= 0.8;
        }else {
            price *= 0.9;
        }
        if (price>=0){
            System.out.println("最终结算价格为"+price);
        }

  4. swich…case结构:

    1. swich…case结构:常常用于实现多条路

      • 优点:效率高;结构清晰
      • 缺点:目前只能对整数(也支持String和枚举),只能判断相等
      • 应用场景:若业务是对整数判断相等,都是应用场景

    3. swich…case是一种特殊的分支结构,可以根据一个整数表达式判断相等,从不同的路口运行代码块

    4. 语法:

      int num = scanner.nextInt;
switch(num){
    case 1:
    	System.out.println("奥特曼");
    case 2:
        System.out.println("怪兽");
    case 3:
        System.out.println("佐菲")
    default:
        System.out,println("人类")
}
7.3 循环结构

  1. 反复执行一段相同或相似的代码

  2. 有条件的执行某语句多次,并非每句必走

  3. 循环三要素:

    • 循环变量的初始化

    • 循环的条件(以循环变量为基础)

    • 循环变量的改变

    • 循环变量:是过程中所反复改变的那个数

      开始         			 -圈数为0
够3圈了吗?	不够	跑一圈	圈数为1
够3圈了吗?	不够  跑一圈 圈数为2
够3圈了吗?	不够	跑一圈 圈数为3
够3圈了吗?	够了	
循环变量是一直在变动的圈数
1)循环变量的初始是0-----int cycle = 0 //表示一圈都还没跑
2)循环的条件是圈数>3----cycle>3 //圈数不够3,则循环跑一圈
3)循环变量的改变是cycle++ //表示每循环一次圈数+1
cycle = 0/1/2/3
    在 cycle = 3 时循环结束

      打印机打印五份简历
份数为0	够5份吗	不够	打印1份	
份数为1	够5份吗	不够	打印1份
份数为2	够5份吗	不够	打印1份
份数为3	够5份吗	不够	打印1份
份数为4	够5份吗	不够	打印1份
份数为5	够5份吗	够了	停止
循环变量是简历的份数
1)循环变量的初始值是0------------------------int piece = 0 
2)循环的条件是份数<5即份数不够5的时候打印-------piece < 5
3)每次进行的操作是打印一份--------------------piece++
    piece = 0/1/2/3/4/5 循环piece=5
    		^ ^ ^ ^ ^
    		有效循环次数5次

  4. while结构

    1. 语法:

      while(boolean){
    语句块------------>反复执行的代码
}

    2. 案例:

      int times = 0;
while(times<5){
    System.out.println("书籍是人类进步的阶梯");
    times++;
}
System.out.println("继续执行...");

      • 执行步骤

        times=0 times<5 true 执行语句块 times++

        times=1 times<5 true 执行语句块 times++

        times=2 times<5 true 执行语句块 times++

        times=3 times<5 true 执行语句块 times++

        times=4 times<5 true 执行语句块 times++

        times=5 times<5 false 结束循环

    3. 自造死循环

      package Day06;

import java.util.Random;
import java.util.Scanner;

public class Guessing {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random rd = new Random();
        int guess = rd.nextInt(1000);
        System.out.println(guess);
        while (true) { //自造死循环
            System.out.println("猜吧");
            int user = sc.nextInt();
            if (user > guess) {
                System.out.println("大啦");
            } else if (user < guess) {
                System.out.println("小啦");
            } else {
                System.out.println("对啦");
                break;
            }
        }
    }
}
      • 用于解决跟数量无关的反复的代码

  5. do…while结构

    1. 语法

      do{
    语句块
}while(boolean);

    2. 执行过程:先执行语句块,再判断while后面的boolean,若为true则执行语句块,若为false则直接结束

    3. while与do…while的对比

      1. while:先判断后执行,有可能一次都不执行
      2. do…while:先执行后判断,最少执行一次
      3. 如果当第1要素与第3要素的代码相同是,首选do…while?

  6. for结构

    1. 语法:

      //   1初始化	2判断		3改变
for(第1要素 ; 第2要素 ; 第3要素){
    语句块----------------反复干的那件事----------4
}

    2. 执行过程:

      1243243243243243…2为false时,循环结束

    3. 循环结构的选择

      1. 先看循环结构是否与次数有关
      2. 有关直接选for
      3. 无关看1/3要素是否相同
        • 相同选do…while
        • 不同选while

  7. break和continue

    • break
      • 跳出循环;
      • 通常跟if一起用,表示在某种情况下跳出循环;
    • continue
      • 跳过本次循环,再次进入循环
      • 通常跟if一起用,表示某种情况下跳过循环;
      • 十分鸡肋,continue能做的事,不用continue通常也能做;
      • 用哪种方式主要看自己的编程思维;

  8. 嵌套循环

    1. 循环中套循环,常常多行多列时使用,外层循环控制行,内层循环控制列;

    2. 执行规则:外层循环走一次,内层循环走所有次;

    3. 建议:嵌套层数越少越好,能用一层就不用两层,能用两层就不用第三层;

    4. break默认只能跳出当前一层循环;

    5. 案例(99乘法表)

      package day05;
//99乘法表
public class MultiTable {
    public static void main(String[] args) {
        int a;
        int b;
        for (a=1;a<=9;a++){
            for (b=1;b<=a;b++){
                System.out.print(a+"*"+b+"="+a*b+"\t");
            }
            System.out.println();
        }
    }
}

8_数组

8.1 数组的特性

  1. 数组也是一种数据类型;

    //这两个不是同一种数据类型,一个是int整型数据类型,一个是整型数组数据类型
int   a ;//声明一个整型变量为a
int[] b ;//声明一个数组,名称为b

  2. 数组是相同数据类型元素的集合;

  3. 是一种引用数据类型;

  4. 将一组类型相同\逻辑相关的数据,存到数组中

8.2 数组的定义

  1. 只要 声明一个数组并且 new 了,其中所有元素都是int型,默认值为0;

  2. 只要 声明一个数组并且 new 了,其中所有元素都是double型,默认值为0.0;

  3. 只要 声明一个数组并且 new 了,其中所有元素都是boolean型,默认值为false;

  4. 案例:

    //声明一个整型数组a,里面有222个元素.每个元素都是int型
int[] a = new int[222];
//声明一个浮点型数组b,里面有333个元素.每个元素都是double型
double[] b = new double[333];
//声明一个布尔型数组c,里面有444个元素,每个元素都是boolean型
boolean[] c = new boolean[444];
//声明一个字符串型数组d,里面有555个元素,每个元素都是String型
String[] d = new String[555];
8.3 数组的初始化

  1. 直接声明并且对数组中的元素赋值

    //当数据量不大的时候可以直接声明的数组后面直接跟大括号进行赋值
int[] f={1,2,3,4};
double[] g={1.1,2.2,3.3,4.5,6.6};
String[] h={"你好","再见","goodbey"};

  2. 声明且new之后跟大括号

    int [] i = new int[]{2,5,8};	//2,5,8如果用这种方式写则后面的的int[]不能写元素个数;
8.4 数组的访问

  1. 通过(数组名.length)可以获取数的长度

    //访问数组的长度 x.length是查询数组x的长度length
int len = a.length;
System.out.println(b.length);
System.out.println(c.length);
System.out.println(d.length);
System.out.println(f.length);
System.out.println(g.length);
System.out.println(h.length);

  2. 通过下标/索引/标号来访问数组中的元素,下标从0开始,最大到(数组长度-1)

    //声明一个名称是arr整数数组,数组里元素的长度是
int[] arr = new int[3];
arr[0] = 100;//使arr数组中第一个值为100
arr[1] = 200;//使arr数组中第二个值为200
arr[2] = 300;//使arr数组中第三个值为300
System.out.println(arr[0]);//输出arr数组中下标为0的数
System.out.println(arr[1]);//输出arr数组中下标为1的数
System.out.println(arr[2]);//输出arr数组中下表为2的数

  3. 数组的遍历/迭代(从头到尾挨个走一遍)

    1. 数组遍历的方法

      int[] arr = new int[100];//声明一个数组arr,数组的元素为整型,数组内的元素有100个
for (int i= 0 ; i<arr.length ; i++){//数组的遍历,给数组里的每个元素赋值为100*i(下标)的值
	arr[i]=100*i;
	System.out.println(arr[i]);
}

    2. 数组遍历的案例(求数组的最大值)

      package day05;
public class MaxOfArray {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
            System.out.println(arr[i]);
        }
        int max = arr[0]; //假设第一个元素的值是最大值
        for (int i = 1; i < arr.length; i++) { //遍历剩下的每个元素
            if (arr[i] > max) {  //如果arr[i]的值大于原来的max
                max = arr[i];    //就把arr[i]的值赋给max
            }
        }
        System.out.println("最大值为"+max);
    }
}

  4. 数组的复制

    1. 使用System.arraycopy( )可以实现数组的复制

      1. System.arraycopy(a,1,b,2,4);

      2. a的位置表示:源数组

      3. 1的位置表示:源数组的起始下标

      4. b的位置表示:目标数组

      5. 0的位置表示:目标数组的起始下标

      6. 4的位置表示:要复制的元素个数

         public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,8,9};
        int[] b = {100,200,300,400,500,600};
        System.arraycopy(a,0,b,0,4);
        for (int i=0;i<b.length;i++){
            System.out.print("["+b[i]+"] ");
        }
	/*
	输出的结果
	[1] [2] [3] [4] [500] [600]
	*/

    2. 使用Arrays.copyOf( )可以实现数组的的复制

      1. int[] b = Arrays.copyOf(a,6);
      2. a的位置表示:源数组
      3. b的位置表示:目标数组
      4. 6的位置表示:目标数组的长度
      5. 若目标数组的长度>源数组的长度,则末尾补默认值
      6. 若目标数组的长度<源;数组的长都,则将末尾截断

    3. 数组的扩容

      1. 数组的长度在创建数组后是不可改变的的,数组元素的内存是连续的

      2. 所谓扩容是指创建一个更大的新数组并将源数组的内容复制进去

        int[] a = {10,20,30,40,50};
a = Arrays.copyOf(a,a.length+1);

      3. 案例:

        package day05;

import java.util.Arrays;

public class MaxOfArray {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
            System.out.print("["+arr[i]+"] ");
        }
        int max = arr[0]; //假设第一个元素的值是最大值
        int lim = arr[0];
        for (int i = 1; i < arr.length; i++) { //遍历剩下的每个元素
            if (arr[i] > max) {  //如果arr[i]的值大于原来的max
                max = arr[i];    //就把arr[i]的值赋给max
            }
        }
        for (int i = 1; i < arr.length; i++) { //遍历剩下的每个元素
            if (arr[i] < lim) {  //如果arr[i]的值大于原来的max
                max = arr[i];    //就把arr[i]的值赋给max
            }
        }
        System.out.println();
        System.out.println("最小值为"+lim);
        System.out.println("最大值为"+max);
        arr = Arrays.copyOf(arr,arr.length+1);
        arr[arr.length-1] = max;
        arr = Arrays.copyOf(arr,arr.length+1);
        arr[arr.length-1] = lim;
        for (int i=0;i<arr.length;i++){
            System.out.print("["+arr[i]+"] ");
        }
    }
}

/*
结果是
[16] [97] [47] [88] [46] [95] [74] [8] [54] [29] 
最小值为16
最大值为8
[16] [97] [47] [88] [46] [95] [74] [8] [54] [29] [8] [16] 
*/

  5. 数组的排序

    • 排序是对数组施加的最常用的算法;

    • 所谓排序,指将数组元素按照从小到大(升序)或从大到小(降序)的顺序重新排列;

    • Java提供的Arrays.sort()封装了数组的排序方法:

      javapackage day04;
import java.util.Random;//添加随机数相关工具包
import java.util.Arrays;//添加跟数组相关的工具包
public class ArrayDemo {
	public static void main(String[] args) {
		int[] arr = new int[10];//声明一个整型数组arr,有10个元素
        Random rand = new Random();
        for(int i=0;i<arr.length;i++){//遍历数组给数组赋值为0-99的随机数
            arr[i]=rand.nextInt(100);
            System.out.println(arr[i]);
        }
        Arrays.sort(arr);//对arr进行升序排列
        for(int i=0;i<arr.length;i++){//遍历数组输出结果,升序结果
             System.out.println(arr[i]);
       	}
        for (int i=arr.length-1;i>=0;i--){//遍历数组输出结果
            System.out.println(arr[i]);//倒序输出就是降序结果
        }
    }
}

9_集合

  1. 是一种数据类型

  2. 数组与集合都可以储存一组数据,区别:数组的长度是固定的,而集合是可伸缩的.

  3. 集合的语法:

    package day05;
import java.util.ArrayList;// 首先要引入ArrayList的包,才可以使用ArrayList函数
import java.util.Arrays;
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<Integer> List = new ArrayList<>();
        List.add(1);//从集合的末尾依次添加元素
        List.add(2);
        List.add(3);
        List.add(4);
        List.add(5);
        System.out.println(List);//最简便的输出方式[1, 2, 3, 4, 5]
        
        int len = List.size();//获取集合的大小/长度
        System.out.println("List的长度为:"+len);//5
    }
}

  4. 集合插入元素:

            List.add(3,10);//[1, 2, 3, 10, 4, 5] 表示在原来集合下标为3的位置插入10这个元素
        System.out.println(List);//其他集合大小不变,往后推
        List.add(3,20);//[1, 2, 3, 20, 10, 4, 5] 表示在原来集合下标为3的位置插入20这个元素
        System.out.println(List);

  5. 删除和清空元素:

    List.remove(3);//删除下标为3的元素
System.out.println(List);//[1, 2, 3, 10, 4, 5]
List.remove(0);//删除下标为0的元素
System.out.println(List);//[2, 3, 10, 4, 5]
List.clear();//清空集合
System.out.println(List);//[]

  6. 获取和设置元素:

    String s = strings.get(2);//获取下标为2的元素的值
System.out.println(s);//four
strings.set(0,"aoteman");//设置下标为0的元素的值为"aoteman"
System.out.println(strings);//[aoteman, three, four, five, six]

  7. 集合顺序相关(升序/乱序):

    package day05;
import java.util.ArrayList;
import java.util.Collections;//先引入排序工具包
import java.util.Random;//引入随机数
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list =new ArrayList<>();//新建一个集合
        Random rand = new Random();
        for (int i=0;i<10;i++){
            list.add(rand.nextInt(100));
        }//用for循环生成一个长度为10的,元素范围在0-99之间的集合
        System.out.println("原始数据为:"+list);//输出原始数据
        System.out.println("---------------------------");
        //对集合元素升序排列
        Collections.sort(list);
        System.out.println("升序之后:"+list);//输出升序之后的数据
        //对集合元素乱序排序
        Collections.shuffle(list);
        System.out.println("乱序之后:"+list);//输出乱序之后的数据和升序的数据对比
    }
}

  8. 代码表格

代码意义
ArrayList<Integer> list = new ArrayList<>;声明一个新的<整数>
int L =list.size();获取集合的长度/大小 →L
list.add()给集合添加元素
list.remove()给集合删除数(下标/元素值)
list.clear清空集合
list.contains()判断集合中是否含有()
list.get(下标)获取集合中的某个数
list.set(下标,元素值)设置集合中下标为x的值为y
Collections.sort(list)升序
Collections.shuffle(list)乱序

10_方法

10.1 方法的意义
  • 每种编程语言中都有方法的概念,也称为:函数\过程
  • 作用:用于封装一段特定的业务逻辑功能------------------->用到"()"都是方法
  • 方法可以被反复多次调用
  • **建议:**尽可能独立,一个方法只干一件事
  • **好处:**减少代码的重复,有利于代码的维护;
  • **何时用:**只要是一个独立的业务功能,就可以封装到一个方法中
10.2 方法的定义

  • 定义方法的五要素

    • 修饰词:统一写成 public static
    • **返回值:**方法可以有返回值,可以无返回值
      • 无返回值:--------返回值类型统一写成void;
      • 有返回值:--------返回值类型写成特定的数据类型即可;
      • 何时有返回值?何时没有返回值?
        • 若方法执行完之后还需要用到方法中的数据---------------有返回值; public static void
        • 若方法执行完之后不需要用到方法中的数据---------------无返回值; public static int
    • **方法名:**见名知意(小驼峰命名法)
    • **参数列表:**方法可以有参,也可以无参
      • 有参可以使方法更加灵活
      • 无参: public static void say ()
      • **有参:**public static int sum (int num1,int num2)
    • **方法体:**具体业务逻辑实现
    //方法一:
public static void say(){
    
}
//方法二:
public static int sum(int num1,int num2){
    
}
10.3 方法的调用方法
  1. 无返回值:方法名(有参传参);
  2. 有返回值:声明一个变量,要求变量的数据类型与返回值一致
  3. return的用法
    • return 值;
      • 结束方法的执行;
      • 返回结果给调用方;
      • 用在有返回值的方法中;必须返回一个值
    • return;
      • 结束方法的执行;
      • 用在无返回值的方法中;
      • 提前结束方法;
10.4 方法的签名

  1. 方法的签名:方法名+参数列表

  2. Java规定:在同一类中,不允许出现签名完全相同的方法

  3. 方法的重载

    public static void say(){}; // say() 是方法的签名
public static void say(){return1;};  //不允许,因为签名是一样的
public static void say(String name){}//因为签名中的参数不一样,这就是方法的重载(overloding),可以
say(); //调用无参say方法
say("zhangsan") //调用String参数say方法

  4. 绑定:编译器在编译时会根据方法的签名(方法名+参数列表)自动绑定方法

10.5 补充
  1. 形参:形式参数,定义方法时的参数是形参
  2. 实参:实际参数,调用方法时的参数为实参
  3. 方法中可以嵌套方法

11_面向对象

引言
  • 面向对象三大特征:封装,继承,多态
  1. 面向过程与面向对象
    • 面向过程:
      1. 以方法为单位来解决问题的编程方式;
      2. 适合简单的业务;(把大象装进冰箱;去银行取钱)
    • 面向对象:
      1. 以对象为单位来解决问题的编程方式;(凡是一个真实的个体都是对象)
      2. 适合复杂的业务;
  2. OO/OOA/OOD/OOP
    • OO (Object-Oriented):面向对象
    • OOA(Object-Oriented Analysis):面向对象分析
    • OOD(Object-Oriented Design):面向对象设计
    • OOP(Object-Oriented Programming):面向对象编程
  3. 高质量代码要素
    • 要求:
    • 复用性好
    • 扩展性好
    • 维护性好
    • 移植性好
    • 健壮性好
    • 可读性好
    • 性能好
11.1 类和对象

  1. 类,变量和方法组成的一种新的数据类型------>引用类型

  2. 类中可以包含:

    • 对象的属性/特征/数据,设计为成员变量

    • 对象的行为/动作/功能,设计为方法

    • class 类名{ //自己创造的数据类型
    成员变量类型 变量名
        
    修饰词 返回值类型 方法名称([参数列表]){
        方法体
    }
}

  3. 每条记录都是一个**对象,**创建对象的过程成为实例化 语法:new 类名();

  4. 引用类型变量

    • 为了能够对实例化的对象进行访问控制,需要使用一个特殊的变量-----引用

    • //  数据类型  引用 指向     对象 
	Student  stu  =  new Student();
//  声明了Student类型的引用stu,指向了一个学生对象

  5. 访问对象的成员变量;调用方法

    • 通过引用名打点来访问对象的成员变量或调用方法

    • Student zg = new Student();
zg.name = "张光";
zg.age = 26;
zg.className = jsd001;
zg.study();
11.2 this和构造
  1. this的作用
    • 只能用在方法中,方法中访问成员变量之前默认都有this.
    • this指代当前对象,哪个对象调用方法,this指的就是哪个对象
  2. 构造方法:构造函数/构造器/构建器
    • 作用:给成员变量赋初始值;
    • 语法:与类同名,没有返回值类型(连void都没有);
    • 调用:在创建(new)对象时被自动调用;
    • 若自己不写构造方法,则编译器默认提供一个无参构造方法;
    • 若自己写了构造方法,则不再默认提供;
    • 构造方法可以重载
    • 成员变量(在整个类里可用)和局部变量(在方法里的是局部变量,范围是当前方法)是可以同名的,此时使用的时候默认采取的是就近原则,此时若像访问成员变量,则this不能省略
  3. this的用法:
    • this.成员变量名------------------------------>访问成员变量
    • this.方法名() ---------------------------------->调用方法(很少用)
    • this() -------------------------------------------->调用构造方法
11.3 继承
  1. 继承
    • 作用：实现代码的复用；
    • 通过：extends实现继承
    • 超类/基类/父类：共有的属性和行为
    • 派生类/子类：特有的属性和行为
    • 一个超类可以有多个派生类，但一个派生类只能有一个超类
    • 继承的特点：传递性
11.4 super关键字

  1. 作用:指代当前对象的超类对象

    • super.成员变量名 : 访问超类的成员变量名

      package ooday02;

public class Doctor extends Person{
    String title;
    Doctor(){
    }
    Doctor(String name,int age,String address,String title){
        this.name = name;
        this.age = age;
        this.address = address;
        this.title = title;
    }
    void cut(){
        System.out.println(name+"正在做手术...");
    }
}

// 更准确的应该是

package ooday02;

public class Doctor extends Person{
    String title;
    Doctor(){
    }
    Doctor(String name,int age,String address,String title){
        super.name = name;
        super.age = age;
        super.address = address;
        this.title = title;
    }
    void cut(){
        System.out.println(name+"正在做手术...");
    }
}

    • super.方法名():调用超类的方法------转11.5.3

    • super():调用超类的构造方法

  2. super与继承的关系

    • Java规定:构造派生类之前必须先构造超类

    • 为了保证这个规定,Java做了两种处理:

      1. 在派生类的构造方法中若没有调用超类构造方法,默认super()调用超类的无参构造方法

        注意:super()调用超类构造方法必须位于派生类构造方法的第一行

      2. 在派生类的构造方法中若自己调用了超类的构造方法,则不再默认提供

      3. 继承的是父类的成员变量和普通方法,不包括构造方法,父类的构造方法是被子类通过super来调用的

11.5 方法的重写

  1. 定义:发生在父子类中,方法名称相同,参数列表相同

    public class Person {
    String name;
    int age;
    String address;
    Person(){
    }
    Person(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address =address;
    }
        void sayHi(){
        System.out.println("大家好,我叫"+name+",今年"+age+"岁了,家住"+address);
    }
}
class Student extends Person{
    String className;
    String stuId;

    Student(){

    }
    Student(String name,int age,String address,String className,String stuId){
        super(name,age,address);
        this.className = className;
        this.stuId = stuId;
    }
    void sayHi(){
        System.out.println("大家好,我叫"+name+",今年"+age+"岁了,家住"+address+"所在班级是:"+className+"学号是:"+stuId);
    }
}

    称为 Student类 重写了 Person类 的 sayHi 方法; ----------------------->子类重写了父类的方法

  2. 重写方法被调用时,看对象的类型来执行方法**(new谁就调谁)**;

  3. 重写中使用super关键字

    1. 子类在重写父类的方法时,可以通过super关键字调用父类的版本;

    2. 案例:

      public class Aoo{
    void show(){
        System.out.println("超类show");
    }
}
class Boo extends Aoo{
    void show(){
        super.show();
        System.out.println("子类show");
    }
}

    3. 如果在新建子类之后需要重写方法,可先调用父类的方法在他的基础上增加;

11.6 final的概述
  • 表示最终的;不可改变的

  1. 特点:

    1. 修饰变量:变量不能被改变

      class Eoo{
    final int a = 5;
    int b = 6;
    void test(){
        a = 55;//编译错误
        b = 66;
    }
}

    2. 修饰方法:方法不能被重写

      class Foo{
    final void show(){}
}
class Hoo extends Foo{
    void show(){ //编译错误
        System.out.println();
    }
}

    3. 修饰类:类不能被继承

      final class Aoo{}
class Boo extends Aoo{} //编译错误
机器人不会数3
关注
专栏目录
Java学习笔记目录索引 (持续更新中)
Guizy
01-15 12万+
Java学习路线目录索引 一、Java基础(省略) Lambda表达式及函数式接口 二、Java数据库 MySQL 一 概念、DDL、DML、DQL、事务、约束等 数据库设计 一 多表关系、三大范式 JDBC 一 基本使用、DAO组件、连接池、JDBCTemplate 三、JavaWeb HTML相关学习 CSS — 常用属性 CSS — 选择器及三大特性 CSS — 网页的布局方式 C...........................
java学习笔记1
09-20
Java学习笔记1 Java学习笔记1是学习Java过程中的笔记，主要记录了Eclipse开发环境中的快捷键使用、编辑功能、查找和调试等知识点。 Eclipse快捷键 Eclipse中有许多快捷键，掌握这些快捷键可以大大提高开发效率。...
Java学习笔记
Piglett的博客
12-30 1220
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java 学习笔记
weixin_42098295的博客
05-13 2030
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7760
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
JAVA学习笔记
少年左岚
01-25 1939
学习java~
Java学习笔记4
xiaoheizi2的博客
08-16 1361
以上是我认为在Java基础中较为重要的概念，以后还会有其他部分的概念笔记，希望这份笔记可以帮到大家；如果各位发现了文档中的错误也请多多指正。
JAVA学习笔记（韩顺平老师）
2301_77385325的博客
04-19 2089
说明：本文为韩顺平老师的JAVA课程学习笔记，仅供自身学习参考，如有纰漏，请多指教，如有帮助，不胜荣幸。
黑马程序员Java学习笔记（源代码+图片+笔记）——集合
weixin_65098078的博客
07-24 1210
黑马程序员Java学习笔记（源代码+图片+笔记）——集合
Java学习笔记一
u013033706的博客
10-23 1559
Java学习笔记一1、Java语言的特点2、Java程序开发过程3、Java虚拟机JVM 学习方式： 书籍：《Java基础教程》 吴仁群 清华大学出版社 1、Java语言的特点 一种面向对象且与平台无关的多线程动态语言 2、Java程序开发过程 文件名.java产生applicationapplets源文件编辑器Java编译器字节码文件由Java解释器执行由Web浏览器执行 图1 Java程...
Java 学习笔记：面向对象
Li__Daxia的博客
03-19 1127
Java 学习笔记：面向对象
(完整版)最全的java学习笔记(必看).pdf
05-27
Java学习笔记 Java是一种流行的编程语言，广泛应用于Android应用程序开发、Web应用程序开发、桌面应用程序开发等领域。以下是Java学习笔记的摘要信息： 一、Java技术基础 * 1.1 编程语言：Java是一种面向对象的...
Java学习笔记(必看经典).pdf
10-20
Java是一种广泛使用的面向对象编程语言，其核心设计原则之一就是"万物皆对象"。面向对象编程（Object-Oriented Programming, OOP）是相对于面向过程编程的一种编程范式，它强调将数据和操作数据的函数封装在一起，...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 388
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 906
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 957
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 477
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 321
默认对常规Session的理解和使用，如何使用Set-Cookie。
JAVA学习笔记：入门篇
"Java学习笔记初步概述" 在Java学习的初期，我们首先会接触到的是Java程序的两种核心运行机制。Java程序的执行依赖于Java虚拟机（JVM），它负责将编译后的字节码文件转化为机器语言，使得Java代码能在不同的操作...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值