Java学习之路

Java精英工程师学习之路——第一阶段

  • 一、JavaSE核心编程基础
    • 1.Java语言概述
      • 1.1如何学习Java——3W1H(重点!!!)
      • 1.2Java开发环境的介绍
      • 1.3第一个Java程序——“HelloWorld”
      • 1.4Java程序的运行机制
      • 1.5Java的本质
      • 1.6Java的特点
      • 1.7Java的分类
      • 1.8Java的基本元素
      • 1.9数据类型、变量、类型转换表示
      • 1.10 IDEA的使用
      • 1.11 补充知识
    • 2.流程控制语句_分支结构
      • 2.1 运算符
      • 2.2 表达式
      • 2.3 输入和输出
      • 2.4 分支语句(if-else、多分支)
      • 2.5 嵌套分支语句
      • 2.6 switch语句
    • 3.流程控制语句_循环结构
      • 3.1循环for/while/do
      • 3.2嵌套循环
      • 3.3break/continue/return
    • 4.数组及数据结构
      • 4.1 数组
    • 4.2 静态数组
    • 4.3 动态数组
    • 4.4 多维数组
    • 4.5 补充知识
    • 5.方法(函数)
      • 5.1 方法的概念
      • 5.2 使用方法的命名
      • 5.3方法的命名规则
      • 5.4方法的语法和组成
      • 5.5方法的调用
      • 5.6补充知识
    • 6.初步面向对象编程
    • 7.继承、抽象
    • 8.接口、多态
    • 9.Java面向对象总结
    • 10.API使用方法——String,ArrayList类
    • 11.Java异常处理机制
    • 12.Swing UI编程AWT布局
    • 13.事件处理模型
    • 14.图形编程
    • 15.Mysql初步应用
    • 16.JDBC编程

一、JavaSE核心编程基础

1.Java语言概述

1.1如何学习Java——3W1H(重点!!!)

3W:What 是什么,Why 为什么,When 什么时候使用
1H:How怎么做
在我们学习和敲代码时,一定要遵循3W1H原则,要明白每个代码的功能,什么时候使用,以及怎么样用。这样才可以锻炼我们的编码能力

1.2Java开发环境的介绍

​  1)JDK、JRE、JVM

  ①JDK((Java Development Kit)):Java开发工具包,JDK是Sun 公司提供的一种免费的_Java软件开发工具包,里面包含了很多用于Java程序开发的工具,最常用的是编译和运行工具。

  ②JRE(Java Runtime Environment):Java的运行环境。

  ​③JVM(Java Virtual Machine):Java运行的虚拟机,JVM是java能够跨平台的核心机制。
Java学习之路_第1张图片
Java学习之路_第2张图片

1.3第一个Java程序——“HelloWorld”

public class HelloWorld{
	public static void main(String args[]){//main方法是程序运行的主入口
		//在IDEA中可以输入sout,进行快速输入System.out.println();
		//新手建议手敲一遍代码,先熟悉,暂时不用快捷键
		//在控制台输出HelloWorld
		System.out.println("HelloWorld");
	}	
}

1.4Java程序的运行机制

​  1)编写程序:首先,程序员使用高级语言编写程序,包括数据结构、算法和逻辑等内容。

​  2)编译程序:程序员使用编译器将程序源代码转换成机器语言代码。编译器将源代码分析、检查、优化,并生成目标代码。

​  3)目标代码:编译器生成的目标代码是一组二进制指令,它们被计算机识别和执行。

​  4)链接程序:在程序执行之前,链接程序将目标代码与其他库文件链接在一起,生成可执行文件,可执行文件包括可执行代码和数据。

​  5)执行程序:最后,计算机将可执行文件加载到内存中,按照指令执行程序。程序被载入内存后,计算机将按照指令的顺序执行程序,直到程序执行完毕或被终止。

  所有Java代码遵循从上往下运行,同一行从左往右运行,并且只运行一次。
Java学习之路_第3张图片

1.5Java的本质

​  定义:Java是一门编译型语言,需要经过编译过程将人类写的代码,转化为电脑能理解的格式才可以运行。

​  ​  ​  ​  ​  ​编译

​  ​本质:.java文件------------>.class字节码文件

1.6Java的特点

​  ​1)简单性:Java语言简单高效。

​  ​​2)高安全性

​  ​​3)可跨平台:可以在各种操作系统下运行。

​  ​​4)可移植性:不需要修改文件即可在其他操作系统下运行。

​  ​​5)健壮性:简单地将就是程序对于各种非法地输入能够有很好地处理,并且使程序能够正常地继续运行下去。

1.7Java的分类

​  1)Java SE:Java核心语法及应用

​  ​2)Java EE:Java Web(Tomcat)

​  ​3)Java ME:移动端(和EE合并)

1.8Java的基本元素

​  ​1)标识符:标识符是指Java程序中自定义的名称,用来表示变量、方法、类、包等。标识符必须遵守一定的命名规则,比如必须以字母、下划线或美元符号开头,后面可以跟着字母、数字、下划线或美元符号等等。标识符就是个名字

​  ​​2)关键字:关键字是Java语言中已经被定义好的具有特殊意义的单词,比如public、class、static等等。关键字不能作为标识符来使用。已经被官方使用的名字,不可以再使用

​​  ​3)常量:常量是指在程序中固定不变的值,比如字符串常量、整数常量、浮点数常量等等。常量在Java中使用关键字final来定义,表示其值不能被修改。

​  ​4)变量:变量是程序中可以改变其值的数据存储空间,比如整型变量、字符型变量、布尔型变量等等。变量需要使用标识符来命名,并且需要在使用之前进行声 明和初始化。可以变化的量,内部存储的东西可以改变。
  i.变量的注意事项
  ​ ①变量的命名规范
  ​  ​必须以字母、下划线或美元符号开头,后面可以跟着字母、数字、下划线或美元符号等等。但是不能以数字开头
​​    ​a.变量名应该以字母、下划线或美元符号开头,不能以数字开头。
  ​  ​b.变量名应该使用驼峰式命名法,即第一个单词小写,后面的单词首字母大写,例如:firstName。
  ​  ​c.变量名应该具有描述性,并且最好不要使用缩写或简写,例如:customerName而不是custName。
​    ​d.如果变量名由多个单词组成,则可以使用下划线分隔它们,例如:last_name。
  ​  ​e.Java是区分大小写的语言,因此变量名也应该区分大小写。

  ​ ②使用规则
  ​  a.先声明再调用

public class Demo{
	public static void main(String[]args){
        	//变量的声明
        	int num1 = 123456;//其中num1就是变量名,等号右边是变量的数值即变量值
        	//变量的调用:完成声明之后,直接使用变量名即变量的调用
        	int num =100;//既声明又赋值
        	int num2;//只声明,不赋值
        	int num3,num4,num5
                int num6=1,num7=2;
        	System.out.println(num1);
    }
}

1.9数据类型、变量、类型转换表示

​​  ​1)数据类型
​​  ​​ 定义:不同的数据有不同的作用,而划分数据的就是数据类型。
​​  ​​ 分类:
​​  ​​ i.基本数据类型

数据类型 字节数 位数 取值范围 备注 封装类(复合类型)
字节类型(byte) 1 8 -27(-128)~27-1==(127)== Byte
短整型(short) 2 16 -215(-32768)~215-1==(32767)== Short
整型(int) 4 32 -231(-2147483648)~231-1==(2147483647)== Integer
长整型(long) 8 64 -263(-9223372036854775808)~263-1==(9223372036854775807)== 必须以l或L结尾,最好使用L Long
单精度浮点型(float) 4 32 3.4e-38~3.4e38 必须以f或F结尾 Float
双精度浮点型(double) 8 64 1.7e-308~1.7e308 Double
布尔类型(boolean) 1(默认) 8(默认) ture or false Boolean
字符类型(char) 2 16 0~216-1==(65535)== 引号里面只能放单个字符,不能放多个。 Character

​​  ​​ ii.复合数据类型
​​  ​​  定义:一般将用户定义的新类型称为复合数据类型。在Java中,类和接口是两种用户定义的复合数据类型。(Scanner,Random……)

​​  ​2)变量
​​  ​​ i.声明变量:数据类型 变量名; ​​ 可以参考一下Java代码

public class Demo {
    public static void main(String[] args) {
        /**
         * 文档注释
         * 姓名:弯弯
         * 年龄:18
         * 身高:180
         * 手机号:123456789
         * 是否已婚:是
         * 性别:男
         * 未知
        */
        //声明变量的格式:数据类型 变量名 = 值;
        String name = "昆宝";
        //声明并赋值变量的格式:数据类型 变量名 = 值;
        int age =18;//“=”为赋值符号
        int height = 180;
        String phone = "123456789";
        boolean marry = true;
        char sex = '男';
    }
}

​​  ​3)数据类型的转换
​​  ​​ i.强制转换
  ​​  ①格式:目标类型 变量名 = (目标类型) 源类型变量名
  ​​  ②规则:a.不能对boolean类型进行类型转换。
  ​​    ​​  b.不能把对象类型转换成不相关类的对象
​  ​​    ​​  c.把容量大的类型转换为容量小的类型,转换过程中可能导致溢出或损失精度

public class QZZH{
    public static void main(String[]args){
        //强制类型转换
        int i=100;
        float b=1000f;
        i = (int) b;
   }
}

​​  ​​ ii.自动转换
  ​​  ①定义:整型、实型、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一个类型,然后进行运算,转换从低级到高级。长度较短的类型可以自动变为长度较长的类型,这种转换即自动转换
Java学习之路_第4张图片

1.10 IDEA的使用

  ​1)快捷键

​  ​ ​文件格式对齐:对齐代码Ctrl+Alt+shift+L 然后选择whole file整个文件对齐(格式化)

​  ​ ​注释:ctrl+/或ctrl+shift+/

  ​2)乱码问题

​  ​ ​解决方案:选择.java文件,右键选择打开方式为记事本,然后另存为,改成我们需要的编码格式

1.11 补充知识

​​  ​1)Java是一门强类型语言,一旦某一个变量被定义类型,如果不经过强制转换,则它永远就是该数据类型了。

  2)前端和后端的区别
​  ​ ​前端:展示给用户看的
​  ​ ​后端:一般用户看不懂,主要负责的是业务逻辑

  3)工作空间(本质——文件夹)
​  ​ ​定义:一个用于存放所有项目的文件夹

  4)项目
​  ​ ​定义:项目可大(签到系统)可小(一个页面)。具备完整功能的代码工程

  5)包(package)
​  ​ ​定义:存放对应类型的文件

  6)文件(class)
​  ​ ​定义:java文件

  7)程序的耦合性
​  ​ ​定义:低耦合性方便替换,高耦合性不容易替换。各个部件或各个功能之间不会太多的相互影响。比如人的器官替换之后会导致死亡,即人是高耦合性,又比如电脑的CPU,可以相互替换,即低耦合性。

  8)可维护性
​  ​ ​定义:如何让程序方便更新和维护。

  9)字符集
​  ​ ​定义:字符集就是存了所有文字的字典。

2.流程控制语句_分支结构

2.1 运算符

  1)定义:用来运算的符号,因为代码中需要一些运算,所以需要使用运算符。

  2)运算符的类型(6种
   i.算术运算符:+,-,*,/,%,++,–
    a++:先使用变量a,再将变量a自增
    ++a:先使用变量a,再将变量a自增

   ii.关系运算符:>,<,>=,<=,==,!=

   iii.布尔逻辑运算符:!,&&,||
     &&(短路且):多个条件都为true,结果才为true
     ||:(短路或):多个条件中,只要其中之一为true,结果为true
     !:求反,将true和false相互转换
     &(且):多个条件都判断
     |(或):多个条件都判断

   iv.位运算符:>>,<<,&,|,^,~
     &(与运算)定义:参加运算的两个数据,按二进制位进行“与”运算。运算规则:0&0=0; 0&1=0; 1&0=0; 1&1=1;即两位同时为“1”,结果才为“1”,否则为0
     |(或运算)定义:参加运算的两个对象,按二进制位进行“或”运算。运算规则:0|0=0; 0|1=1; 1|0=1; 1|1=1;参加运算的两个对象只要有一个为1,其值为1
     ^(异或运算)定义:参加运算的两个数据,按二进制位进行“异或”运算。运算规则:0^0=0; 0^1=1; 1^0=1; 1^1=0;参加运算的两个对象,如果两个相应位为“异”(值不同),则该位结果为1,否则为0。
     ~(按位取反)定义:将数据,按二进制位进行"取反"运算。运算规则:0–>1,1–>0(0变1,1变0)

   v.赋值运算符:=,及其扩展赋值运算+=,-+,%=,/=

   vi.三目运算符
     i.格式:条件表达式?返回值1(true):返回值2(false)

public class TernaryOperator {
    public static void main(String[] args) {
        //三目运算符
        //格式:条件表达式?结果1(true):结果2(false)
        //逻辑表达式、关系表达式
        String answer = 5>4?"正确":"错误";
        System.out.println(answer);//正确
        System.out.println(3>4?"正确":"错误");//错误
    }
}

2.2 表达式

   1)定义:是一个式子,由运算符和变量组成

​   2)规则:从左往右运行

2.3 输入和输出

   1)输入
     定义:用户给电脑信息,在控制台中输入。

public class ScannerDemo{
    public static void main(String[]args){
        //输入工具(Scannr),由java官方写好的工具
        Scanner scanner = new Scanner(System.in);
        //从scanner的工具箱中获取输入数字的工具,输入前最好有提示
        System.out.print(" 请输入数字:")
        int num = scanner.nextInt();
    }
}

   2)输出
     定义:电脑给用户信息

public class OutputDemo{
    public static void main(String[]args){
    	//Idea的快捷键sout
        System.out.println("我是输出的写法哦");
    }
}

2.4 分支语句(if-else、多分支)

  定义:可以用来判断的语句,需要条件==[条件是布尔值或结果为布尔值的表达式]==
   1)if(范围)

public class IfDemo{
    public static void main(String[]args){
        /*
        if(条件){
			代码块
		}
        */
        if(5>4){
        	System.out.println("正确");
        }
    }
}

  2)if-else(范围)
   定义:if-else语句是Java中最基本的分支语句。if语句用于在满足条件时执行某些代码,而else语句用于在不满足if条件时执行另外一些代码。

public class If_elseDemo{
    public static void main(String[]args){
        /*
        if(条件){//true
			代码块
		}else{//false
			代码块
		}
        */
        if(4>5){
        	System.out.println("正确");
        }else{
			System.out.println("错误")
		}
    }
}

  3)if-else if-else(多分支、范围)
   定义:用于检查多个条件,若某一条件成立,则执行相应的代码块,并跳过其他条件的检查。

public class If_else_ifDemo{
    public static void main(String[]args){
        /*
        if(条件){//true
			代码块
		}else if(条件2){
			代码块
		}else if(条件3){
			代码块
		}else{
			代码块
		}
        */
        if(9==11){//显然不等,进入下一个else if
			System.out.println("9等于11");
		}else if (9==12){//显然不等,进入else if
			System.out.println("9等于12");
		}else if (9==13){//显然被不等 进入 else
			System.out.println("9等于13");
		}else {
			System.out.println("9等于10");
		}
    }
}

2.5 嵌套分支语句

  1)定义:在一个分支结构中又完整的嵌套了另一个完整的分支结构,里面的分支的结构称为内层分支外面的分支结构称为外层分支。规范:不要超过3层。

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的成绩");
        double result = scanner.nextDouble();
        System.out.println("请输入你的性别");
        char sex = scanner.next().charAt(0);
        if (result > 8.0){
            System.out.println("恭喜你进入决赛");
            if (sex == '男'){
                System.out.println("进入男子组");
            } else {
                System.out.println("进入女子组");
            }
        } else {
            System.out.println("你已被淘汰");
        }
    }
}

2.6 switch语句

   1)switch语句(固定值判断/单一变量)
    用于对表达式的值进行多重匹配,若某一匹配成功,则执行相应的代码块。break的作用是打断语句,根据需要,决定要不要加break,default的位置没有要求
   2)switch的变量可以有什么数据类型? int其他?
    答:swtich的变量的数据类型数量和java的版本有关。
     ①在Java7之前,switch只能支持byte,short,int,char或者相关对应的封装类以及Enum类型
     ②在Java7中,switch增加支持了String类型,即String,byte,short,int,char,Enum类型(6种)
     ③在Java7之后,switch支持10种类型
     i.基本类型:byte,char,shourt,int(4种)
     ii.对应包封装:Byte,Short,Character,Intege;String,Enum(6种)
   总结:实际上switch只支持int类型。Java实际只能支持int类型的switch语句,其他的类型是如何支持的?
     1)基本类型的byte,char,short都可以自动向上转换为int类型,实际上用的还是int。
     2)基本类型包装类Byte,Short,Character,Integer,由于Java的自动拆箱机制,可以把这些对象自动转换为基本类型。
     3)String类型实际switch比较的是string.hashCode值,它是一个int类型。4)enum类型实际比较的是enum的ordinal值(表示枚举值的顺序),它也是一个int类型。

switch (表达式/变量) {
            case1:
                // 匹配成功时执行的代码
                break;
            case2:
                // 匹配成功时执行的代码
                break;
            default:
                // 所有值都不匹配时执行的代码
        	break;
        }

3.流程控制语句_循环结构

3.1循环for/while/do

  1)for(计算机运算第一步是初始变量,第二步是范围判断,第三是执行循环体,最后再增量)
    i.格式

/*for(初始变量;范围判断;增量){
    //循环体;
}*/
public class Test{
    publib static void main(String[]args){
        int sum=0;
        for(int i=1;i<=100;i++){
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

    ii.优点
      for循环有固定循环次数,确定循环次数的语句。while根据条件进行循环,不确定循环次数的语句
Java学习之路_第5张图片
  2)while
    i.格式:

while(条件){
        //条件:布尔值或结果为布尔值的表达式
        //当条件为true时,会不断执行内部语句
	//循环体;
}
//Eg
public class Test{
    public static void main(String[] args){
        int count=0;
        while(count<10){
            count++;
            System.out.println("HelloWorld"+count)
        }
    }
}

  3)do-while
    i.格式:先执行do里面的语句,再判断。若为true则继续执行do里面的语句。

do{
    语句;
}
while(布尔表达式);

3.2嵌套循环

  1)局部变量
    定义:每个变量都有一定的作用域

public class Test{
    public int num =1;//类变量(局部变量)
    public static int num=1;//全局变量
    public static void main(String[] args){
        int a=1;// 方法变量,main方法里的变量(局部变量)
        for(int i=0;i<10;i++){
            for(int j=1;j<10;j++){//循环里,局部变量,j只存在自己的循环中               
            }
        }
    }
} 

  2)嵌套循环(画三角形)

public class Demo1 {
    public static void main(String[] args) {
        //第一个图
        /*for(int i=5;i>0;i--){
            for(int j=1;j

        //第二个图
/*            *
             ***
            *****
           *******
         **********
       */
        /*for(int i=1;i<=5;i++){//y轴,行
             for(int j=1;j<=5-i;j++){
                 System.out.print(" ");
             }
             for(int j=1;j<=i*2-1;j++){
                 System.out.print("*");
             }
            System.out.println();
        }*/

        //第三个图 菱形
        /*for(int i=1;i<=5;i++){
            for(int j=1;j<=5-i;j++){
                System.out.print(" ");
            }
            for(int j=1;j<=2*i-1;j++){
                System.out.print("*");
            }
            System.out.println();
        }
        for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            for(int j=7;j>=(i*2)-1;j--){
                System.out.print("*");
            }
            System.out.println();
        }*/

        //第四个图
        /*for(int i=1;i<=5;i++){
            for(int j=1;j<=5-i;j++){
                System.out.print(" ");
            }
            for(int j=1;j<=2*i-1;j++){
                if(j==1 ||j==2*i-1)
                System.out.print("*");
                else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
        for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            for(int j=7;j>=(i*2)-1;j--){
                if(j==7||j==(i*2)-1){
                    System.out.print("*");
                }
                else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }*/

        //第五张图
        /*for(int i=1;i<=5;i++){//y轴,行
             for(int j=1;j<=5-i;j++){
                 System.out.print(" ");
             }
             for(int j=1;j<=i*2-1;j++){
                 if(j==1 || j==i*2-1){
                     System.out.print("*");
                 }
                 else if(i==5){
                     System.out.print("*");
                 }
                 else{
                     System.out.print(" ");
                 }
             }
            System.out.println();
        }*/
    }
}

3.3break/continue/return

  1)continue
    结束本次循环,然后进入下一次循环。
  2)break
    退出整个循环,即循环结束。或者终止语句(switch中的case)打断switch或终止循环
  3)return
    返回值或者作为函数(方法)的暂停

public class Demo {
    public static void main(String[] args) {
        //break的使用
        System.out.print("break的输出:");
        for(int i=1;i<=10;i++){
            if(i == 5){
                break;
            }
            System.out.print(i+" ");//break的输出:1 2 3 4
        }
        System.out.println();
        //continue的使用
        System.out.print("continue的输出:");
        for(int i=1;i<=10;i++){
            if(i == 5){
                continue;
            }
            System.out.print(i+" ");//continue的输出:1 2 3 4 6 7 8 9 10 
        }
    }
}

4.数组及数据结构

4.1 数组

  1)数组==(数据的集合)==
    ①概述:一次性声明大量的用于存储数据的变量;这些要存储的数据通常都是相同类型的数据
    ​②定义:数组是一种用于存储多个相同类型数据的存储模型。
    ​③作用:一个变量名存储多个数值,变量名指向这个十六进制的物理地址。变量只能存储一个值。
Java学习之路_第6张图片
  4)格式:
    ①数据类型[] 变量名
    ②数据类型 变量名[]

public class ArraryDemo{
    public static void main(String[]args){
        int[] arr;//定义了一个int类型的数组,数组名是arr
        int arr[];//定义了一个int类型的变量,变量名是arr数组
    }
}

  5)规则:
    ①Java中的数组必须先初始化,然后才可以使用。初始化是为数组中的数组元素分配内存空间,并为每个元素赋值
    ​②数组初始化方式:i.动态初始化 ii.静态初始化
    ​③动态初始化:初始化时只指定数组长度、有系统的为数组分配初始值。只给长度,不给具体内容
    ④动态初始化的格式:数据类型[] 变量名 = new 数据类型[数组长度];
    ⑤一般数组用循环一起用
  6)数组的访问:
    ①数据变量的访问方式:数组名[索引(下标)]
    ②数组内部保存的数据的访问方式:数组名[索引]//编号从0开始
    ③索引(小标):索引是数组中数据的编号方式,作用就是用于访问数组中的数据,数组名[索引]等同于变量名是一种特殊的变量名;索引从0开始,是连续的,逐一增加,每次加1。下标从0开始,最大到数组长度-1
  7)数组的访问原理
    ​①原理数组的地址存在栈空间中,数组的内存在堆空间中生成,要访问数组中的元素时,由栈空间的地址寻找到堆空间中,然后访问数组里的元素。
  8)数组的索引和数组的长度
    ​①数组的索引是从0开始,而数组的长度是从1开始

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        //静态数组的创建
        //方法一
        int[] arr1 = new int[3];//声明一个长度为3的整数数组,所有的元素初始化为0
        //arr1 = {1,2,3};//如果使用new运算符创建了数组对象并初始化了其大小,则不能再使用类似于arr1 = {1,2,3};这样的语法来给数组赋值。因为大括号花括号语法只能用于声明和静态初始化数组,而不能用于重新赋值。
        arr1[0]=1;
        arr1[1]=2;
        arr1[2]=3;
        System.out.print("arr1:");
        for(int i=0;i<=(arr1.length)-1;i++){
            System.out.print(arr1[i]+" ");
        }
        //方法二
        int[] arr2 = {1,2,3};//声明一个长度为3的整数数组,并给每个元素赋值
        System.out.println();
        System.out.print("arr2:");
        for(int j=0;j<=Array.getLength(arr2)-1;j++){
            System.out.print(arr2[j]+" ");
        }
        System.out.println();
        /*
        * Arrays.toString()
        * Arrays.toString()方法可以将一个数组转换为字符串并返回。该方法通常用于调试和日志记录。
        */
        String StringArray1 = Arrays.toString(arr1);
        System.out.println("StringArray1:"+StringArray1);//StringArray1:[1, 2, 3]
        String StringArray2 = Arrays.toString(arr2);
        System.out.println("StringArray2:"+StringArray2);//StringArray2:[1, 2, 3]

        /*
        * Arrays.sort()
        * Arrays.sort()方法可以对一个数组进行排序。该方法默认按升序对数组进行排序。
        */
        int[] arr3={5,3,2,1};
        System.out.println("初始的arr3:"+Arrays.toString(arr3));//初始的arr3:[5, 3, 2, 1]
        Arrays.sort(arr3);//将数组进行排序
        System.out.println("排序后的arr3:"+Arrays.toString(arr3));//排序后的arr3:[1, 2, 3, 5]
    }
}

4.2 静态数组

  1)静态数组
    ①定义:声明数组时就确定其大小的数组,一旦固定长度,长度就无法改变
    ​② 格式:数据类型[] 数组名={};

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        //静态数组的创建
        //方法一
        int[] arr1 = new int[3];//声明一个长度为3的整数数组,所有的元素初始化为0
        //arr1 = {1,2,3};//如果使用new运算符创建了数组对象并初始化了其大小,则不能再使用类似于arr1 = {1,2,3};这样的语法来给数组赋值。因为大括号花括号语法只能用于声明和静态初始化数组,而不能用于重新赋值。
        arr1[0]=1;
        arr1[1]=2;
        arr1[2]=3;
        System.out.print("arr1:");
        for(int i=0;i<=(arr1.length)-1;i++){
            System.out.print(arr1[i]+" ");
        }
        //方法二
        int[] arr2 = {1,2,3};//声明一个长度为3的整数数组,并给每个元素赋值
        System.out.println();
        System.out.print("arr2:");
        for(int j=0;j<=Array.getLength(arr2)-1;j++){
            System.out.print(arr2[j]+" ");
        }
    }

4.3 动态数组

  ​3)动态数组
    ​​①定义:在运行时根据需要动态增长或缩小的数组。Java中的动态数组是通过ArrayList类实现的
    ​;​②格式:数据类型[] 数组名=new 数据类型[数组长度];
    ​​③规则:动态数组声明后,复合类型素组初始化数值为null,基本类型的默认值(初始化)为0

package Demo;

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //1.创建一个空的ArrayList
        ArrayList<Integer> myList = new ArrayList<Integer>();
        //2.向ArrayList中添加元素
        myList.add(10);
        myList.add(20);
        myList.add(30);
        System.out.println(myList.toString());
        //3.获取ArryList中的元素
        int element = myList.get(0);//获取第一个元素
        System.out.println(element);//10
        //4.修改ArrayList中的元素
        myList.set(0,100);//将数组第一个位置的值改为100
        //5.删除ArrayList中的元素
        myList.remove(0);//删除第一个元素
        System.out.println(myList.toString());
        //6.获取ArrayList的大小
        int size = myList.size();
        //7.遍历ArrayList中的元素
        for(int i=0;i<myList.size();i++){
            int element1=myList.get(i);
            System.out.println(element);
        }
    }
}

    ④查找数组中的最大值元素

import java.util.Scanner;
//静态数组
public class ArrayDemo3 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int[] arr ={123,190,334,159};
        int max=arr[0];
        for(int i=1;i<=(arr.length)-1;i++){//不用从0开始,因为index=0的值已经赋值给max了
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}
//动态数组
//数组长度为5,随机数1-100,填入数组,然后求最大值
public class arrayDemo {
    public static void main(String[] args) {
        Random random = new Random();
        int[] intArray=new int[5];
        int max = 0;
        for (int i = 0; i <intArray.length ; i++) {
            intArray[i]=random.nextInt(100)+1;
            max=intArray[0];
            if(max<intArray[i]){
                max=intArray[i];
            }
        }
        Arrays.sort(intArray);
        System.out.println("数组的最大值为:"+max);
        System.out.println(Arrays.toString(intArray));
    }
}

4.4 多维数组

​  1)定义:存放了数组的数组,即多维数组
​  2)一维数组和二维数组
    ①一维数组:数组内没有存放数组,只是普通内容。
    ②二维数组:数组里存放的就是若干个一维数组
    ③三维数组:存放多个二维数组

4.5 补充知识

​  1)如果是复合类型的数组,动态初始化之后,内容默认为null(空)
​  2)”==“和“equals”的区别
​  ​  ①“==”判断的是物理地址
​  ​  ②Java节省内存的机制:相同变量占同一个空间(指向相同的内存空间)

public class Demo{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入字符串:");
        String str = scanner.next();
        System.out.println("输入的是:"+str);
        System.out.println(str=="y");//false
        System.out.println("y"=="y");//true
    }
}

​  ​  ③比较字符串相等的方式:str.equals(“y”)。equals对比的是内容复合类型使用
​  3)代码冗余
​  ​  ①​定义:重复出现的代码多
​  ​  ②​代码的问题:①写的繁琐 ②不方便维护
​  ​  ​③解决方案:函数(方法),将重复的代码封到函数里,然后调用函数即可减少冗余

  ​数组题
  ​ 1)定义一个长度为 100 的数组,随机填充 0~1000 之间的整数,要求数组里的每个数字之间不能重复。

public class Demo1 {
    public static void main(String[] args) {
        Random random =new Random();
        int[] intArray = new int[5];
        for (int i = 0; i < intArray.length; i++) {
            int newNum=random.nextInt(5);
            //先获取随机出来的数字,判断该数字是否重复
            for(int j=0;j<i;j++){//循环已经出现过的数字
                if(newNum==intArray[j]){
                    newNum=random.nextInt(5);
                    System.out.println("出现重复");
                    j=-1;
                }
            }
            intArray[i]=newNum;
    }
        System.out.println("初始数组:"+Arrays.toString(intArray));

    }
}

  ​ 2)定义一个长度为 10 的数组,随机填充 5~30 之间的整数。 打印数组的所有内容,然后再次打印在数组中出现重复过出现的数字。

import java.util.Arrays;
import java.util.Random;

//2、定义一个长度为 10 的数组,随机填充 5~30 之间的整数。 打印数组的所有内容,然后再次打印在数组中出现重复过出现的数字。
public class Demo2 {
    public static void main(String[] args) {
        Random random =new Random();
        int[] intArray =new int[10];
        int num=0;//存重复的数
        for (int i = 0; i < intArray.length; i++) {
            intArray[i]=random.nextInt(10);
            for(int j=0;j<i;j++){
                num=intArray[i];
                if(num==intArray[j]) {
                    System.out.println("数组中重复的数为:"+num);
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(intArray));
    }
}

  ​ 3)定义一个长度为 10 的数组,随机填充 0~50 之间的整数, 然后根据十位数的数字将其排列成一个新数组。例如 [2, 10, 3, 32, 5, 41, 10, 11, 20], 随后重新排列数组,要求新数组形式如下 [[2, 3, 5], [10, 11], [20],[32],[41]]。

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

//定义一个长度为 10 的数组,随机填充 0~50 之间的整数, 然后根据十位数的数字将其排列成一个新数组。
//例如 [2, 10, 3, 32, 5, 41, 10, 11, 20], 随后重新排列数组,要求新数组形式如下
//[[2, 3, 5], [10, 11], [20],[32],[41]]。
public class Demo3 {
    public static void main(String[] args) {
        //工具包
        Random random = new Random();

        //定义变量和数组
        int zero = 0, one = 0, two = 0, three = 0, four = 0, five = 0;
        int[] storeArray = new int[10];
        int temp = 0;
        //随机数
        for (int i = 0; i < storeArray.length; i++) {
            storeArray[i] = random.nextInt(51);
        }

        for (int i = 0; i < storeArray.length; i++) {
            temp = storeArray[i];
            if ((temp / 10) == 0) {
                zero++;//十位数为0的情况
            } else if ((temp / 10) == 1) {
                one++;//十位数为1的情况
            } else if ((temp / 10) == 2) {
                two++;//十位数为2的情况
            } else if ((temp / 10) == 3) {
                three++;//十位数为3的情况
            } else if ((temp / 10) == 4) {
                four++;//十位数为4的情况
            } else if ((temp / 10 == 5)) {
                five++;//十位数为5的情况
            }
        }

        int[] zeroArray = new int[zero];
        int[] oneArray = new int[one];
        int[] twoArray = new int[two];
        int[] threeArray = new int[three];
        int[] fourArray = new int[four];
        int[] fiveArray = new int[five];

        int flag0 = 0;
        int flag1 = 0;
        int flag2 = 0;
        int flag3 = 0;
        int flag4 = 0;
        int flag5 = 0;
        for (int i = 0; i < storeArray.length; i++) {
            if (storeArray[i] < 10 && flag0 < zeroArray.length) {
                zeroArray[flag0] = storeArray[i];
                flag0++;
            } else if ((storeArray[i] >= 10 && storeArray[i] < 20) && flag1 < oneArray.length) {
                oneArray[flag1] = storeArray[i];
                flag1++;
            } else if ((storeArray[i] >= 20 && storeArray[i] < 30) && flag2 < twoArray.length) {
                twoArray[flag2] = storeArray[i];
                flag2++;
            } else if ((storeArray[i] >= 30 && storeArray[i] < 40) && flag3 < threeArray.length) {
                threeArray[flag3] = storeArray[i];
                flag3++;
            } else if ((storeArray[i] >= 40 && storeArray[i] < 50) && flag4 < fourArray.length) {
                fourArray[flag4] = storeArray[i];
                flag4++;
            } else if ((storeArray[i] >= 40 && storeArray[i] < 50) && flag5 < fourArray.length) {
                fourArray[flag5] = storeArray[i];
                flag5++;
            }
        }
        /*System.out.println(Arrays.toString(storeArray));
        System.out.println(Arrays.toString(zeroArray));
        System.out.println(Arrays.toString(oneArray));
        System.out.println(Arrays.toString(twoArray));
        System.out.println(Arrays.toString(threeArray));
        System.out.println(Arrays.toString(fourArray));
        System.out.println(Arrays.toString(fiveArray));*/
        int[][] Array={zeroArray,oneArray,twoArray,threeArray,fourArray,fiveArray};
        System.out.println(Arrays.deepToString(Array));
    }
}

5.方法(函数)

  
    

5.1 方法的概念

  1)定义:具有独立功能的代码块组织成为一个整体,使其具有特殊功能的代码。用来解决一类问题的代码的有序集合,是一个功能模块。函数是一串具有特定功能的,高度封装的代码块。
    ①方法必须先创建才可以使用,该过程成为方法的定义
    ​②方法创建后并不是直接可以运行的,需要手动使用后才执行,该过程成为方法调用。
  2)常见错误
    ​①方法不能定义在main方法中
    ​②方法的名称区分大小写
  ​3)方法–>面向过程,(函数—>面向对象)的声明
    ​​语法格式:
    ​访问修饰符 返回类型 方法名([参数列表]){
    ​​//方法体
    ​​}
  ​4)五大要素
    ​​①访问修饰符:方法允许被访问的权限范围。public(公共的),protected(受保护的),privated(私有的)

访问提示符 同一个类中 同一个包中 不同包中的子类 不同包中的非子类(任意类)
private
default
protected
public

5.2 使用方法的命名

5.3方法的命名规则

5.4方法的语法和组成

5.5方法的调用

5.6补充知识

6.初步面向对象编程

7.继承、抽象

8.接口、多态

9.Java面向对象总结

10.API使用方法——String,ArrayList类

11.Java异常处理机制

12.Swing UI编程AWT布局

13.事件处理模型

14.图形编程

15.Mysql初步应用

16.JDBC编程

你可能感兴趣的:(Java,Java学习,java,学习)