JavaEE基础语法

JDK1.8安装与卸载

1.卸载

• 删除java的安装目录

• 删除JAVA_HOME

• 删除path下关于java的信息

2.安装

• 百度搜索JDK8,找到下载地址

• 同意协议

• 下载电脑对应的版本

• 双击安装JDK

• 记住安装的路径

• 配置环境变量

  1. 我的电脑-->右击--->属性

  2. 环境变量-->JAVA_HOME

  3. 配置path变量

• 测试JDK是否安装成功

  1. 打开cmd（win+R）

  2. java -version

JavaSE

1.八大基本数据类型

import sun.applet.Main;
​
public class DOY1 {
    public static void main(String[] args) {
        //整数类型
        int num1=100000000;
        byte num2=100;
        short num3=111;
        long num4=30L;//LANG类型要在数字后面加L表示
​
        //小数:浮点型
        float num5=50.1f;//float类型需要在数字后面加F
        double num6=3.1;
        //字符
        char name = '张';
        //布尔值：是非
        boolean fu =true;
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);
        System.out.println(num5);
        System.out.println(num6);
        System.out.println(name);
        System.out.println(fu);
​
    }
}
​

• 扩展1：java中的进制表示

  //整数扩展   ：进制 二进制ob  十进制 八进制0 十六进制0x
          int i1=10; //十进制
          int i2=010;//八进制
          int i3=0x10;//十六进制
          System.out.println(i1);
          System.out.println(i2);
          System.out.println(i3);

• 扩展2：浮点数拓展：银行业务如何表示钱

  float：缺点：有限，舍入误差，大约接近却不等于

  //最好不要用浮点型

  //可以使用数学工具类：BigDecimal

• 强制转换：在变量前面加要转换的类型

  public class dou2 {
      public static void main(String[] args) {
          char i='a';
          char i2='郭';
          System.out.println(i);
          System.out.println((int)i);//强制转换
          System.out.println(i2);
          System.out.println((float)i2);//强制转换
      }
  }
  注意点：
      1.不能对布尔值进行转换
      2.不能把对象类型转换为不相干的类型
      3.在把高容量转换为低容量的时候强制转换的时候可能存在内存溢出，或者精度问题
      4.低容量转高容量可以自动转换
  ​

• 制表符

  public class dou2 {
      public static void main(String[] args) {
       //   char i='a';
          char i2='\u0061';
          char i3='\u0062';
          char i4='\u0063';
          System.out.println(i2);
          System.out.println(i3);
          System.out.println(i4);
  ​
  ​
          System.out.println("张晓静\n小公主");//\n:换行
          System.out.println("张晓静\t小笨蛋");//\t制表符
      }
  }

2.变量

1.局部变量 ：只可以在代码块中使用，必须声明初始值.

public class Doy2
{   
    public static void main(String[] args) {
        String name="张晓静"; //局部变量，只可以在当前代码块中使用
        System.out.println(name);
    }
    static {
        System.out.println(name);  //在其他代码块会预警
    }
}
​

2.类变量：同类的出现而出现，同类的消失而消失，定义在方法体外。

​
public class Doy2
{
    /*
    实例变量:定义在方法体外，从属于对象
    方法1：可以在变量前加static修饰符，即可表示当前所属类
     */
    static String name2="郭晋科@张晓静";
    int age=20;
    public static void main(String[] args) {
       // Doy2 doy2 = new Doy2(); //方法1：可以通过把对象new出来，获取对象的变量值
        System.out.println(name2);
    }
​
    
}       

public class Doy2
{
    /*
    实例变量:定义在方法体外，从属于对象
    方法2：可以不加static修饰符，这个修饰符表示静态的，用过new一个对象来获取其中的类成员
     */
    String name2="郭晋科@张晓静";
    int age=20;
    public static void main(String[] args) {
        Doy2 doy2 = new Doy2(); //方法1：可以通过把对象new出来，获取对象的变量值
        System.out.println(doy2.name2);
    }
}

3.常量：用final修饰，常量是不允许修改的。

public class Doy2
{
 static final String name="张晓静";
​
    public static void main(String[] args) {
        System.out.println(name);
    }
}
​

3.基本运算符

1.逻辑运算符

package DOY2;
​
public class Demo02 {
    //二元运算符
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int c=30;
​
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println((double)a/b);  //这边因为a和b都是int类型的所以除出来的数都会取整，所以需要将其强转为double类型后再做计算
    }
}
​

package DOY2;
​
public class Demo03 {
    public static void main(String[] args) {
        long a =124123456789L;
        int b=100;
        short  c=123;
        byte d=124;
        System.out.println(a+b+c+d);  //如果说这几个不同的数据类型中有long类型的话，那么最后的结果也是long类型
        System.out.println(b+c+d);//如果说这几个不同的数据类型中不存在long类型的话最后默认返回都是int类型
        System.out.println(c+d);
​
    }
}
​

package DOY2;
​
public class Demo04 {
    public static void main(String[] args) {
        //关系运算符返回布尔值，用于判断是否为真：true：真false ：假
        int a=10;
        int b=20;
        int c=21;
​
        System.out.println(c%a);   //这边的%为取c/a得到的余数，java中称为取模
        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 DOY2;
    
public class Demo01 {
    //自增or自减：一元运算符
    public static void main(String[] args) {
        int a=10;
        int b=a++;   //先赋值给b，a再自增
        int c=++a;   //a先自鞥,再赋值给c
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        
         //幂运算2^3,像数学中的这种运算我们通常使用java中的工具类来实现：MATH
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}
​

package DOY2;
​
public class Demo05 {
    public static void main(String[] args) {
        //逻辑运算符：与（and）或（or），非（取反）
        boolean a=true;
        boolean b=false;
        System.out.println("a&&b:"+(a&&b));  //两个变量都为真，结果为真
        System.out.println("a&&b:"+(a||b));  //有一个为真，结果为真
        System.out.println("!(a&&b):"+(! a&&b));//取反，如果返回为真结果为假，如果返回为假，结果为真
​
        //短路运算:验证当第一个判断返回为false的时候是否还会之后另外一个判断
        int c=5;
        boolean d=(c<4) &&(c++<4);
        System.out.println(d);
        System.out.println(c);
​
​
    }
}

2.位运算

package Doy3;
​
public class Demo01 {
    public static void main(String[] args) {
        /*
        位运算：了解就行，与二进制打交道
        A=0011 1100
        B=0000 1101
        A&B=0000 1100  对两个值的每一位做计算同时满足某个位的值为1，那么这一位就是1，否则就是0 （与）
        A|B=0011 1101  满足有一个是1，那么的到的值就是1      （或）
        A^B=0011 0001  两个值中对应的位数相同返回0，不相同返回1  亦或。
        ~B=1111 0010  去对应位数相反的值  （取反）
         */
​
​
       /*
       案例：面试常问，优点，效率高
       计算2*8=16位运算是如何就散的
       <<   *2
       >>   /2
​
​
       0 的二进制表示是 0000
       1 的二进制表示是 0001
       2 的二进制表示是 0010
       3 的二进制表示是 0011
       4 的二进制表示是 0100
       5 的二进制表示是 0101
       6 的二进制表示是 0110
       7 的二进制表示是 0111
       8 的二进制表示是 1000
​
        根据位运算<<来实现
        */
        System.out.println(2<<3);//意思就是先将2转化为二进制，然后再向做异动三位的到的数再转为十进制，意思就等同于2的三次方
    }
}

3.偷懒符

package Doy3;
​
public class Demo02 {
    public static void main(String[] args) {
     int a=100;
     int b=200;
     a+=b;//a=a+b;   //偷懒方法慎用
     b-=a;//b=b-a
        System.out.println(a);
        System.out.println(b);
    }
}

4.字符串拼接符

package Doy3;
​
public class Demo03 {
    //字符串连接符
    public static void main(String[] args) {
        int a=100;
        int b=200;
        //得出结论：字符串加前面会把变量进行拼接，如果加在后面，则前面的变量将正常计算
        System.out.println(
                ""+a+b
        );
        System.out.println(
                a+b+":"
        );
    }
}

5.三元运算符

package Doy3;
​
public class Demo04 {
    //三元运算符
    public static void main(String[] args) {
​
        //语法：x ? y : z
        //如果x==true则返回y，否则返回z
        int a=10000;
        String zxj =a<100 ? "及格" :"滚蛋";
​
        System.out.println(zxj);
    }
}

4.包机制

包就等同于文件夹，不同的包可以包含不同的文件名称，每个java文件的最上方会显示包名称，包以关键字packages表示

package Doy3;  //表示当前的包名
import Doy3.*;  //导入这个包中所有的类
public class Demo04 {
    //三元运算符
    public static void main(String[] args) {
​
        //语法：x ? y : z
        //如果x==true则返回y，否则返回z
        int a=10000;
        String zxj =a<100 ? "及格" :"滚蛋";
​
        System.out.println(zxj);
    }
}

5.使用Scanner类实现用户交互

1.使用next接收数据

package Doy4;
​
import java.util.Scanner;
​
public class Demo01 {
    //使用SCanner接收用户数据
    public static void main(String[] args) {
​
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据");
        String str=scanner.next();//使用next接收数据的话，只会获取空格之前的字符
        System.out.println("当前输入内容为:"+str);
        scanner.close();
    }
}

2.使用nextLine接收数据

package Doy4;
​
import java.util.Scanner;
​
public class Demo01 {
    //使用SCanner接收用户数据
    public static void main(String[] args) {
​
        Scanner scanner2 = new Scanner(System.in);
        System.out.println("请输入数据");
        String str=scanner2.nextLine();  //使用nextLine接收用户数据的话，则可以获取到回车之前的所有字符
        System.out.println("当前输入内容为:"+str);
        scanner2.close();
    }
}

3.Scanner进阶

例题1

package Doy4;
​
import java.util.Scanner;
​
public class Demo02 {
    //Scanner进阶
    public static void main(String[] args) {
        //进阶内容：根据从键盘输入的值来判断输入的类型
        int a=0;
        float b=0.0f;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数");
      if (scanner.hasNextInt()) {   //hasNextInt用于判断输入的数是不是整数
            a=scanner.nextInt();//接收传进来的数据
          System.out.println("整数数据："+a);
      }else {
          System.out.println("当前输入不为整数");
      };
        System.out.println("请输入一个小数值");
      if (scanner.hasNextFloat()){//hasNextFloat用于判断输入的值是不是小数float类型
          b=scanner.nextFloat();//接收传进来的数据
          System.out.println("小数值为："+b);
      }else {
          System.out.println("不为小数值");
      }
​
        scanner.close();
    }
}

例题2

package Doy4;
​
import java.util.Scanner;
​
public class Demo03 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并且每次输入都可以显示当前总共输入的数和以及自动计算平均值
        Scanner scanner = new Scanner(System.in);
        double sun=0;
        int count=0;
        System.out.println("请输入你的数字");
        //循环判断是否还有输入合法的数字
        while (scanner.hasNextDouble()){
            double num=scanner.nextDouble();
            sun=sun+num;
            count++;
            System.out.println("当前输入的数字为:"+num+"当前总数为"+sun+"当前总共输入的数字个数为"+count+"当前平均数为"+(sun/count));
        }
​
    }
}

6.选择结构

1.if单选结构

package Doy05;
​
import java.util.Scanner;
​
public class Demo01 {
    public static void main(String[] args) {
​
        /**
         * if单选：语法：if (判断条件){执行的代码} 
         */
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
​
        if (s.equals("张小静")){   //这边的equals方法的作用表示比较字符串是否相等，满足条件才会走代码块，否则跳过当前判断，直接走下面的代码
            System.out.println(s);
        }
        scanner.close();
​
    }
}

2.多选结构

package Doy05;
​
import java.util.Scanner;
​
public class Demo01 {
    public static void main(String[] args) {
​
        /**
         * if else 双选结构 ，
         * 语法 if （判断条件） { 执行的的代码}
         *    else {这边是不满足if的条件，就会执行这边的内容}
         */
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
​
        if (s.equals("张小静")){   //这边的equals方法的作用表示比较字符串是否相等，满足条件才会走代码块，否则跳过当前判断，直接走下面的代码
            System.out.println(s);
        }else
        {
            System.out.println("郭晋科");
        }
        scanner.close();
​
    }
}

3.多重选择结构

package Doy05;
​
import java.util.Scanner;
​
public class Demo01 {
    public static void main(String[] args) {
​
        /**
         * if elseif  else 多重选择结构 ，
         * 语法 if （判断条件） { 执行的的代码}
         *    else if {这边是不满足if的条件，就会执行这边的内容}
         *    else if {不满足上一个if，继续走到当前判断，不满足的话走下一个if}
         *    else if {}
         *    else {上面的判断都不满足的话，最终执行else中的代码块}
         */
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        //这边的equals方法的作用表示比较字符串是否相等，满足条件才会走代码块，否则跳过当前判断，直接走下面的代码
        if (s.equals(1)||s.equals(2)||s.equals(3)){
            System.out.println("春天来来");
        }else if (s.equals(4)||s.equals(5)||s.equals(6))
        {
            System.out.println("夏天来了");
        } else if (s.equals(7)||s.equals(8)||s.equals(9)) {
            System.out.println("秋天来了");
        } else if (s.equals(10)||s.equals(11)||s.equals(12)) {
            System.out.println("冬天来了");
        }else
        {
            System.out.println("你离开了，再也回不来了");
        }
        scanner.close();
​
    }
}

4.if嵌套结构

package Doy05;
​
import java.util.Scanner;
​
public class Demo01 {
    public static void main(String[] args) {
​
        /**
         * if嵌套结构
         * 语法： if （条件）{if （条件） {} }
         * 案例：做一个登录的逻辑，先输入一个账号，判断是否合法，合法的话继续输入密码，否则提示账号不存在，然后判断密码是否合法，合法的话显示登录成功，否则登录失败
         * */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入账号信息");
        String s = scanner.nextLine();
        //这边的equals方法的作用表示比较字符串是否相等，满足条件才会走代码块，否则跳过当前判断，直接走下面的代码
        if (s.equals("张小静")){
            System.out.println("请输入密码");
            String p = scanner.nextLine();
            if (p.equals("zxj")){
                System.out.println("登录成功");
            }else {
                System.out.println("密码错误，请纠正后重新输入");
            }
        }else {
            System.out.println("账号信息不存在，请先注册");
        }
        scanner.close();
​
    }
}

5.switch选择结构

package Doy05;
​
public class Demo02 {
    public static void main(String[] args) {
​
        String zxj ="张小静";
​
        switch (zxj){//括号中接收一个值用做判断下面的层级
            case "张小静":
                System.out.println("老婆你好");
                break; //break可选的，当不写的时候也会执行下面的逻辑，如果写的话将终止下面的逻辑
            case "1":
                System.out.println("你是谁");
            case "2":
                System.out.println("你是谁");
            case "3":
                System.out.println("你是谁");
            case "4":
                System.out.println("你是谁");
            default:  //default相当于else，当上面每一层的case都不满足的话执行：后面的语句
                System.out.println("报上名来");
​
        }
​
    }
}

7.循环结构

1.while循环

package Doy05;
​
public class Demo03 {
    //while循环，作用：在一定范围内循环，直到不满足为止
    public static void main(String[] args) {
        int a=0;
        while (a<1000){
            System.out.println(a);
            a++;
        }
    }
}

2.do while循环

package Doy05;
​
public class Demo03 {
    // do while循环，作用：先循环do的代码块，再判断while中的范围是否满足，
    //和wjele的区别就是 do while先执行一次再去看范围是否满足，而while则是先判断，再执行
    public static void main(String[] args) {
        int a=0;
        int b=0;
        do {
            a=a+500;
            b++;
            System.out.println(a);
            System.out.println(b);
        }while (a<1000);
    }
}

3.for 循环

package Doy06;
​
public class Demo01 {
    public static void main(String[] args) {
        /**                   初始化/条件/更新
         * FOR循环：语法 for （1=0;i<100;i++）
         */
​
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
​
    }
}

1.案例1

计算0到1000之间奇数和偶数的和

package Doy06;
​
public class Demo01 {
    public static void main(String[] args) {
        /**                   初始化/条件/更新
         * FOR循环：语法 for （1=0;i<100;i++）
         */
        int js_qty=0;
        int os_qty=0;
​
        for (int i = 0; i < 1000; i++) {
            if (i%2 !=0){ //判断i能否被2除尽，如果除不尽的话就是奇数
                js_qty+=i; //奇数
​
            }else {
                os_qty+=i; //偶数
            }
        }
        System.out.println("奇数和未"+js_qty);
        System.out.println("偶数和未"+os_qty);
    }
}

2.案例2

循环打印出1到1000中能被3整除的数，且，每行显示5个数字

package Doy06;
public class Demo02 {
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            if (i%3 ==0){
                System.out.print(i+"\t");  //这边print(i+"\t")表示不自动换行每个i后面拼一个制表符\t
            }
            if (i%(3*5)==0){//判断是否为第5个可以被三整除的数，如果是的话就换行
                System.out.println();//println就表示自动换行
            }
        }
    }
}

3.案例3

打印九九乘法表

package Doy06;
​
public class Demo03 {
    public static void main(String[] args) {
        //打印99乘法表
​
​
        for (int j = 1; j <=9 ; j++) {//最外层的循环是循环行数：j=1，那么i<=j,所以第一行只有一条，如果j=2.那么i<=2,就会第二行输出两条，依次类推
            for (int i = 1; i <=j ; i++) {//里面的循环是循环列数
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }
​
    }
}

4.案例四

打印等腰三角形

package Doy07;
​
public class Demo01 {
​
    public static void main(String[] args) {
​
        for (int i = 1; i <=5 ; i++) {
            for ( int j=5; j>=i; j--){//打印空的倒三角形
                System.out.print(" ");
            }
            for (int j = 1; j <=i ; j++) {//循环左边正的三角形
                System.out.print("*");
            }
            for (int j = 1; j <i ; j++) {//循环右边的正三角形
                System.out.print("*");
​
            }
​
            System.out.println();
        }
    }
}

5.循环终止

1.break详解

package Doy06;
​
public class Demo04 {
​
    public static void main(String[] args) {
        for (int i = 0; i <1000 ; i++) {
            System.out.println(i);
            if (i>=500){
                break;           //这边判断成立的话将终止当前循环，直接跳出循环体外执行下面的逻辑
            }
        }
        System.out.println("nnn");
    }
}

2.continue详解

package Doy06;
​
public class Demo04 {
​
    public static void main(String[] args) {
        for (int i = 0; i <10 ; i++) {
            if (i==5){
                continue;           //这边判断成立的话跳出当前循环，直接返回循环体最开始的位置进行下一次循环
            }
            System.out.println(i);
        }
        System.out.println("nnn");
    }
}

8.方法

1.方法定义

顾名思义：方法是为了可以更快的做一件事情，比如：max，sum这种在elsx中经常用到的方法就是为了方便计算和统计
​
注意：方法的唯一特定就是要保持原子性，一个方法不能同时干两件事。
​
方法分为有参方法和无参方法：清洗请看代码：

package Doy07;
​
public class Demo02 {
    public static void main(String[] args) {
        //这里括号中的两个100表示实际参数
       int a= add(100,100); //调用add方法
        System.out.println(a);
        SJX();  //调用SJX方法
​
​
    }
​
    //这边定义了一个带有两个参数add的方法，在main方法中进行调用
    //这里的a，b表示形式参数
    public  static int add (int a,int b){//有参方法
        return a+b;
    }
​
    public  static void SJX(){//这边没有返回值的类型，而是又关键字void代替，说明该方法无需返回值
        for (int i = 1; i <=5 ; i++) {
            for ( int j=5; j>=i; j--){//打印空的倒三角形
                System.out.print(" ");
            }
            for (int j = 1; j <=i ; j++) {//循环左边正的三角形
                System.out.print("*");
            }
            for (int j = 1; j <i ; j++) {//循环右边的正三角形
                System.out.print("*");
            }
​
            System.out.println();
        }
    }
​
}

2.return的用法

return的用法除了返回值以外，还可以终止程序，例如：

package Doy07;
​
public class Demo03 {
    public static void main(String[] args) {
        int max=max(10000,1000);
        System.out.println(max);
    }
    
    public  static int max (int num1,int num2){
        int retur=0;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;  //如果说这边加了return的话，那么系统会在这边终止,返回当前的值
        }
        if (num1>num2){
            retur =num1;
​
        }else {
            retur=num2;
        }
        return retur;
    }
}

3.方法重载

特点：

方法名一样,

参数类型不同，或者参数个数不同，顺序不同等，

编译器会根据代码定义的参数去匹配具体用哪个方法。

例如：

package Doy07;
​
import java.util.Scanner;
​
public class Demo03 {
    public static void main(String[] args) {
        /*
        int max=max(10000,1000);
        System.out.println(max);
         */
​
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的名字，我们将为您自动查找到您的夫人信息");
        String num=scanner.nextLine();
        String name= max(num);
        System.out.println(name);
​
    }
​
    public  static int max (int num1,int num2){//这边方法名为max，两个int参数
        int retur=0;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;  //如果说这边加了return的话，那么系统会在这边终止,返回当前的值
        }
        if (num1>num2){
            retur =num1;
​
        }else {
            retur=num2;
        }
        return retur;
    }
    public static  String max (String lp){//这边方法名为max，参数为String
        String name="";
        if (lp.equals("郭晋科")){
            name="您的夫人名为："+"张小静";
        }
        return name;
    }
}

4.使用命令行传递参数

1.定义main方法:

package Doy07;
​
public class Demo04 {
    public static void main(String[] args) {
        for (int i = 0; i <args.length ; i++) {
            System.out.println("args"+"["+i+"]"+args[i]);
        }
    }
}

2.在当前文件所在位置打开cmd窗口

1.执行javac命令编译java文件
    D:\java\项目管理\基础语法\JAVASE\Doy07>javac Demo04.java
2.使用命令../退回路径至存放包的原始目录
    D:\java\项目管理\基础语法\JAVASE\Doy07>cd ../ 
3.使用 ‘java 包名.文件名不加后缀 参数 ’格式进行传递参数进行输出结果
    D:\java\项目管理\基础语法\JAVASE>java Doy07.Demo04 I LOVE YOU ZHANG XIAO JING
    args[0]I
    args[1]LOVE
    args[2]YOU
    args[3]ZHANG 
    args[4]XIAO
    args[5]JING    

5.可变参数

特征：一个参数可以传多个值，前提必须是最后一个参数为可变参数格式如下：

package Doy07;
​
public class Demo05 {
    //可变参数
    public static void main(String[] args) {
       kb(1,2,3,4,5,6);
    }
    public static void kb(int ... num){
        for (int i = 0; i < num.length ; i++) {
            System.out.println(num[i]);        
    }
}
​

6.递归

通过不停的调用本身来处理数据，尽量不用，了解就行

package Doy07;
​
public class Demo06 {
    //递归：通过不停的调用本身的方法来处理数据，慎用
    public static void main(String[] args) {
        System.out.println(ff(4));
    }
    public static int ff (int num){
        if (num==1){//首先第一次传进来的时候为4，直接走下面的判断，直到传进来的数为1
            return 1;
        }else {
            //走到这边的话不停的调用本身方法，如果传进来的是4，
            //  4 * （4-1） * (4-1-1) * (4-1-1-1),直到传进来的数等于1，就会停止调用，这就是递归
            return num*ff(num-1);
        }
    }
}

9.数组

1.数组的定义

特点：

数据类型的唯一性，长度唯一性，下标由0开始。

代码如下：

package Doy08;
​
public class DeMo01 {
    public static void main(String[] args) {
        //数组的定义
       int[] num;//1.声明类型为int，数组名为num的数组
       num=new int[10];//2.创建一个数组，下标最大为10
        //3.为数组内容赋值
        num[0]=1;
        num[1]=2;
        num[2]=3;
        num[3]=4;
        num[4]=5;
        num[5]=6;
        num[6]=7;
        num[7]=8;
        num[8]=9;
        num[9]=10;
        int sum=0;
        for (int i = 0; i < num.length; i++) {//num.length:获取数组num的长度
            sum=sum+num[i];//循环累加计算数组的总长度
        }
        System.out.println(sum);
    }
}

2.栈和堆的讲解

栈（Stack）：
栈是一种线性数据结构，它的特点是先进后出（Last In, First Out，LIFO）。
用于存储方法调用的局部变量、方法调用和返回地址等。
在函数调用时，函数的参数和局部变量会被压入栈中，当函数执行完毕后，这些数据会被弹出。
栈的大小是有限的，通常较小。
    
堆（Heap）：
堆是一个用于动态分配内存的区域，它的分配和释放不是由编译器自动管理的，而是由程序员手动管理。
用于存储动态分配的对象，例如通过 new 或 malloc 分配的对象。
堆的大小通常比栈大，并且可以动态地增长。
关于你提到的数组和空间开辟：
​
在栈上分配的数组是由编译器自动管理的，它的大小在编译时确定，函数的局部变量和数组通常存储在栈上。

3.创建数组的几个方式

package Doy08;
​
public class DeMo02 {
    public static void main(String[] args) {
        //数组的几个创建方式
        //1.静态初始化：创建+赋值
        int[] a={1,2,3,4,5};
        System.out.println(a[0]);
​
        //2.动态初始化-包含默认初始化：声明的时候定义数组长度，如果没有为数组的某个元素赋值的话默认就是类型的默认值
        int[] b =new int[10];
        b[1]=5;
        System.out.println(b[0]);
    }
}

4.数组总结

1.其长度是确定的，数组一旦创建，其大小无法变更
2.其类型必须相同，不允许出现混合类型
3.数组中的类型可以是任何类型
4.数组变量属于引用类型，数组可以看做对象，数组的每个元素可以看做是对象的成员变量，数组本身就是对象，java中的对象是在堆中的，因此无论是原始数据类型还是其他类型，数组本身就是在堆中的。
​
​

5.增强for循环

快捷方式：数组名.for

package Doy08;
​
public class DeMo03 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5,6};
        //增强for循环：没有下标，直接遍历数组所有元素
        for (int array : arrays) {
            System.out.println(array);
        }
    }
}

6.数组反转

package Doy08;
​
public class DeMo03 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5,6};
        //先调用arays（反转数组），得到反转后的数组再用array方法依次打印
        array(arays(arrays));
    }
​
​
    /**
     * 遍历数组方法
     * @param array
     */
    public static void array (int[] array){
        for (int i = 0; i <array.length ; i++) {
            System.out.print(array[i]+"\t");
        }
    }
    /**
     * 数组反转
     */
    public  static int[] arays (int[] arays ){
        //1.获取传进来数组的长度将其赋给这个变量
        int[] ruseult =new int[arays.length];
​
        //反转操作
        //循环还是从i开始，j=ruseult.length-1的意思就是将数组反过来循环，先取最后一个下标，依次往前循环
        //i <arays.length的意思就是取最大下标的时候结束，比如长度为6，你们她的最大下标就是6-1，每次循环就会更新i递增，j递减
        for (int i = 0,j=ruseult.length-1; i <arays.length ; i++,j--) {
            //原数据1 2 3 4 5 6
            //第一次循环i=0,那么j=arays[6-1],取最大下标对应的值就是6
            //这边返回的就是
            //下标为5的值就是传进来数组最小的下标
            ruseult[j]=arays[i];
        }
        //返回所有循环后的数组
        return ruseult;
    }
}

7.多维数组

多维数组又称嵌套数组，将许多个数组组合嵌套起来形成的数组，又为下标中的下标

package Doy08;
​
public class DeMo04 {
    public static void main(String[] args) {
        //多维数组
        //解析：多维数组又称嵌套数组，就是一个数组中的几个元素中的某个元素又是一个数组，案例如下
        //多维数组用[][]定义，语法{{}，{}，{}}
        int[][] arrays={{1,2},{3,4},{5,6},{7,8},{9,10}};
​
        for (int i = 0; i <arrays.length ; i++) {//首先判断这个最外层的数组包含几个字数组，取下标开始循环，
            for (int j = 0; j <arrays[i].length ; j++) {//通过取到最外层的下标来获取里面字数组的长度，也是从0开始循环下标
                System.out.println(arrays[i][j]);
            }
        }
    }
    public  static  void pl (int[] arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.println(arrays[i]);
        }
    }
​
​
}

10.Arrays工具类

Arrays是java中的工具类，里面的一些方法可以拿来直接使用

package Doy08;
​
import java.util.Arrays;//工具类
​
public class DeMo05 {
    public static void main(String[] args) {
        int[] arrays ={1,29,5,34,0,};
       // System.out.println(Arrays.toString(arrays));
        Arrays.sort(arrays);//sort先对arrays进行升序排序
        System.out.print(Arrays.toString(arrays));//然后调用toString方法打印
        Arrays.fill(arrays,0);//fill方法是字符串填充，数组名后面加参数
        System.out.println(Arrays.toString(arrays));
    }
}

11.冒泡排序

package Doy08;
​
import java.util.Arrays;
​
public class DeMo06 {
    //冒泡排序
    public static void main(String[] args) {
        int[] a={12,23,11,0,9,67,2};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }
    public static int [] sort (int[] arrays ){
        //最外层循环总共需要循环的轮数
        for (int i = 0; i <arrays.length-1 ; i++) {
            int num;
​
            //，每一轮需要循环几次
            //举例，如果循环12345，那么比较规则如：1比较2；2比较3.3比较4,4比较5，所以要比较四次
            //然后每一轮结束，那么比较的次数就会少1，如：第一次比较出了2最大，那么直接比较2比较3.3比较4,4比较            5，所以要比较四次
            //所以每次都需要减去循环的轮数。
            // 第一轮 1和2,2和3,3和4,4和5,5个数比较四次
            // 第二轮 2和3,3和4,4和5,5个数比较三次，所以这边的范围就需要减去一个轮数
            for (int j = 0; j <arrays.length-1-i ; j++) {
                if (arrays[j+1]>arrays[j]){ //每次循环判断后一个数是否大于前一个数
                    num=arrays[j]; //利用变量先存储一下前一个数
                    arrays[j]=arrays[j+1]; //将后一个数赋值给前一个数
                    arrays[j+1]=num;//将前一个数赋值给后一个数；
                }
            }
        }
        return arrays;
    }
}

面向对象

1.类与对象的创建及调用

1.创建两个类，一个类定义属性和方法，另一个类用来调用这个类的属性和方法

package Doy09;
//属性
public class Demo01 {
    String name;
    int age;
    double sg;
​
    public void stout (){
        System.out.println("姓名："+this.name+"\t"+"年龄:"+this.age+"\t"+"身高:"+sg);
    }
}

package Doy09;
//调用上面的属性方法
public class Demo02 {
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        demo01.name="钱多多";
        demo01.age=100;
        demo01.sg=0.1;
        demo01.stout();
        Demo01 demo011 = new Demo01();
        demo011.name="张晓静";
        demo011.age=100;
        demo011.sg=1.0;
        demo011.stout();
    }
}

2.构造器详解

//一个类即使什么也不写，这个类也会默认存在一个构造器
//构造器的本质就是用来NEW这个类
//构造器的定义：没有返回值，名称与类名一致
//如果存在了有参构造，如果需要调用无参构造的话，类本身需要显示定义，否则会报错
//可以存在多个构造器，这边用到方法重写的特性

package Doy09;
//构造器
public class Demo01 {
    String name;
    int age;
​
    //一个类即使什么也不写，这个类也会默认存在一个构造器
    //构造器的本质就是用来NEW这个类
    //构造器的定义：没有返回值，名称与类名一致
    //如果存在了有参构造，如果需要调用无参构造的话，类本身需要显示定义，否则会报错
    //可以存在多个构造器，这边用到方法重写的特性
    public Demo01() {//无参构造
    }
    public Demo01(String namne,int age){//有参构造
        this.name=namne;
        this.age=age;
    }
​
}

package Doy09;
//方法
public class Demo02 {
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01("张晓静",20);
        System.out.println(demo01.name+"\t"+demo01.age+"\t");
    }
}

3.封装

特点：属性变为私有，使用getset调用

好处：提高程序的安全性，包含数据

隐藏代码实现细节

处理非法数据

package Doy09;
//封装
public class Demo01 {
   private String name;//private修饰符表示变量是私有的，只能通过getset来调用
   private int age;
​
    public Demo01() {
    }
    public Demo01(String namne,int age){
        this.name=namne;
        this.age=age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}

调用

package Doy09;
//方法
public class Demo02 {
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        demo01.setName("张晓静吃屁屁");
        System.out.println(demo01.getName());
    }
}

4.继承

继承就是拥有被继承类的属性和方法
需要主要只支持一个字类继承一个父类，但是一个父类可以被继承多个子类
​

父类：

package Doy09;
//父类
public class Demo01 {
   private String name;//private修饰符表示变量是私有的，只能通过getset来调用
   private int age;
​
    public Demo01() {
    }
    public Demo01(String namne,int age){
        this.name=namne;
        this.age=age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}

子类

package Doy09;
//子类
public class jsc extends Demo01 {//关键字表示extends继承Demo01的所有属性和方法
​
}

调用子类

package Doy09;
//方法
public class Demo02 {
    public static void main(String[] args) {
        jsc jsc = new jsc();
        jsc.setName("张晓静");//因为jsc这个类继承了Demo01,所以这边可以取到Demo01的所有属性和方法
        System.out.println(jsc.getName());
    }
}

5.SUPER详解

super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类发方法或者构造方法中
3.super和this不能同时使用构造方法
4.父类如果没有无参构造，子类也不能有无参方法
与this、的区别：
代表对象不同、 
    this、：本身调用者这个对象
    super：代表父类对象的应用
前提：
    this：没有继承也可以用
    super：只能在继承条件下才可以使用
构造方法：
    this();本类的构造
    super（）父类的构造

父类：

package Doy09;
//父类
public class Demo01 {
    public String name="我是钱多多的爸爸";
    public int age=100;
​
    public Demo01() {
        System.out.println("爸爸的构造器执行了");
    }
​
    public void  add() {
        System.out.println("钱多多叫了一声");
    }
}

子类：

package Doy09;
//子类
public class jsc extends Demo01 {//关键字表示extends继承Demo01的所有属性和方法
public String name="钱多多生了哇";
public int age=3;
​
public void text (String name){
    System.out.println(name);
    System.out.println(this.name);
    System.out.println(super.name);
}
​
    public void add (){
​
        text("钱多多叫了两声");
    }
​
    public void text (){
    add();
    this.add();//调用当前类的add方法
    super.add();//调用父类的add方法
​
    }
​
    public jsc(String name) {
        this.name = name;
    }
​
    public jsc() {
        this("小汉堡");//这里的supper是隐藏代码，当程序new子类的无参构造的时候，默认先会执行父类的无参构造方法
        System.out.println(this.name);
        System.out.println("儿子的构造器执行了");
    }
}

测试类：

package Doy09;
//
public class Demo02 {
​
    public static void main(String[] args) {
        jsc jsc = new jsc();
       // jsc.text("张晓静大汉堡");
     //   jsc.text();
    }
}

6.重写

概念：
需要有继承关系，子类重写父类的方法，方法名和参数列表必须相同，方法体不同
为啥需要重新：
因为父类的功能不一定能满足子类，所以需要重新定义

父类

package Doy09;
​
public class B {
    public void add (){
        System.out.println("我是你父亲，你在调用我的方法");
    }
}

子类

package Doy09;
​
public class A extends B{
    @Override
    public void add() {
        System.out.println("我是A，我重写了父亲的方法");
    }
}

测试

package Doy09;
​
public class TEST {
    public static void main(String[] args) {
        B a = new A();
        a.add();
​
        A a2 = new A();
        a2.add();
    }
}
/*
输出结果：
我是A，我重写了父亲的方法
我是A，我重写了父亲的方法
​
*/

7.多态

多态注意事项：
1.多态是针对方法的，属性没有多态
2.父类和子类有联系
3.存在条件：继承关系，父类引用指向子类对象
拓展：
1.static 方法属于类，不属于实例
2.final 常量
3.private方法

package Doy09;
​
public class TEST {
    public static void main(String[] args) {
        //A:子类；B：父类
        B b = new B(); //像这个对象就是引用父类的方法，所以他只能获取到父类的方法
        
        //这边就用到了多态的性质：父类的引用指向子类的对象
        B b1 = new A();//这边是通过new子类，然后返回父类的引用，所以获取到的也是父类的方法
        b1.add();
​
        A a2 = new A();//这边的话就是new了子类，因为子类继承父类的所有方法，所以这边既可以取到子类的方法，也可以取到父类的方法
        a2.add();
    }
}

8.instanceof的用法

概念：用于比较两个引用类型是否存在父子继承关系

package Doy10;
​
import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;
​
import java.sql.SQLOutput;
​
public class text {
    //案例：使用instanceof区分不同类之间是否存在父子关系
    //A父类；B：子类；C：子类
    public static void main(String[] args) {
        Object b = new B();  //利用多态的原理：父类的引用指向子类的实例
        if (b instanceof A){ // true   Object是所有类的父类，他们之间用instanceof作比较，如果是父子关系，就会返回true
            System.out.println("我们是父子关系");
        }else {
            System.out.println("我们不是父子关系");
        }
        if (b instanceof B){ //true
            System.out.println("我们是父子关系");
        }else {
            System.out.println("我们不是父子关系");
        }
​
        if (b instanceof C){//false
            System.out.println("我们是父子关系");
        }else {
            System.out.println("我们不是父子关系");
        }
        if (b instanceof String){//false
            System.out.println("我们是父子关系");
        }else {
            System.out.println("我们不是父子关系");
        }
    }
}

9.类型转换

有点：减少重复代码，提供效率，随用随取（向上或向下转型）

1.高转低

父类的引用指向子类的实例，如果需要用子类的方法，需要强制转换为子类类型

package Doy10;
​
public class Text02 {
    public static void main(String[] args) {
        //A类型的引用指向B的实例，所有这边只可以取到A的方法
        A a = new B();
        a.sun();//这是A的方法，如果需要取到B的方法，需要将其转换为B类型
        B a1 = (B) a;//转换为类型
        a1.add();
        /*
        你在调用父类中的sun方法
        你调用了B的方法
         */
    }
}

2.低转高

如果需要调用父类的方法，需要向上转型，但是会丢失一些子类原有的方法

package Doy10;
public class Text03 {
    public static void main(String[] args) {
        B b = new B();
        b.add();  //调用B本身的方法
        A a=b;   //低转高无需强转，但是很有可能会丢失本身的方法
        a.add();  //这边是报错的
    }
}

10.抽象类

概念：以abstract修饰

1.抽象类无法被实例NEW，只能通过子类继承的方式重写方法来实现
2.抽象类中可以写普通的方法，普通的类不可以写抽象的方法
3.抽象方法必须在抽象类中

package Doy10;
//抽象类  //以abstract修饰
public abstract class C  {
​
    //抽象方法：只有方法名字，没有方法实现，需要有子类继承这个类，重写抽象类的方法
    public abstract  void add();
​
    /*
    1.抽象类无法被实例NEW，只能通过子类继承的方式重写方法来实现
    2.抽象类中可以写普通的方法，普通的类不可以写抽象的方法
    3.抽象方法必须在抽象类中
     */
​
}

通过继承抽象类来实现其中的方法

package Doy10;
//子类
public class B extends C {
​
    @Override
    public void add() {
​
    }
}

11.接口的定义与实现

1.约束
2.定义一些方法，让不同的人实现
3.接口不和类一样，类以class修饰，接口以interface修饰。
4.接口不能被实例化，没有构造方法
5.接口中的方法通过实现类中以implements来继承
6.实现类中的方法必须重写接口中的方法，一个实现类可以继承多个接口，以逗号隔开。
代码如下：

1,定义两个接口

package Doy11;
​
public interface UserSersr {
    void add();
    void update();
    void delete();
}

package Doy11;
​
public interface UserSeresr {
    void run();
    void orderby();
}

2。通过implements关键字来实现接口中的方法

package Doy11;
​
public class UserSers implements UserSersr, UserSeresr {
    @Override
    public void add() {
​
    }
​
    @Override
    public void update() {
​
    }
​
    @Override
    public void delete() {
​
    }
​
    @Override
    public void run() {
​
    }
​
    @Override
    public void orderby() {
​
    }
}

12，异常处理与捕获

待学习；

MySql数据库

1.安装

Windows下安装MySQL详细教程 - m1racle - 博客园 (cnblogs.com)