狂神笔记

JavaSE

前奏

学习方法

记录

多写代码，多些笔记，多写文章

交流，思维，技能

分享，提问(怎么了)，思考(为什么)

坚持

Blog==有效的记忆

总结与思考

文笔组织能力

学习总结能力

逻辑思维能力

帮助他人，结交朋友

​ 冰冻三尺非一日之寒

博客平台----wordpress、typecho

博客园

预科

1. io设备

i–>input输入

o–>ouput·输出

2. dos命令

环境安装

配置环境变量

1.添加JAVA_HOME–>变量的值=安装路径(bin的上级目录)

2.配置path–>%JAVA_HOME%\bin

​ %JAVA_HOME%\jre\bin

cmd–>java -version测试是否成功

Hello World

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

编译–>javac

运行–>java

文件名与类名保持一致

程序运行机制

IDEA安装

IDE–＞集成开发环境

入门

所有的标识符都应该以大小写、$、_开头

命名规则

包名：小写

类名:驼峰 所有单词首字母大写

变量名、方法名:小驼峰 lastNameAge

常量名:大写,中间加_

数据类型

基本数据类型

整数类型

int

byte

short

long–>l

浮点类型

float–>f

double

字符类型

char

String–>不是一个关键字，类

布尔类型

引用数据类型

类

接口

数组

拓展

//整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x
        int i=10;
        int i2=010;//8
        int i3=0x10;//16  0~9  A~F
        //浮点数拓展
        //float 有限的离散的  舍入误差  约数
        // 避免浮点数进行比较 BigDecimal数学工具类
        //double
        float f=0.1f;
        double d=1.0/10;
        System.out.println(f);
        System.out.println(d);
        System.out.println(f==d);
        //0.1
        //0.1
        //false
        float d1=212114343134431f;
        float d2=d1+1;
        System.out.println(d1==d2);
        //true
        //字符类拓展
        char c1='a';
        char c2='中';
        System.out.println((int)c1);
        System.out.println((int)c2);
        //所有的字符本质都是数字
        //编码Unicode 2字节 65536 2 16
        //U0000 UFFFF
        char c3='\u0061';
        System.out.println(c3);
        //转义字符
        // \n--换行 \t--制表符
        String sa = new String("hello world");
        String sb = new String("hello world");

        System.out.println(sa==sb);
        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);

        //布尔值拓展
        boolean flag = true;
        //if (flag==true)与if (flag)是一样的
        //Less is More! 代码要精简易读

数据类型转换

byte，short，char–>int–>long–>float–>double

运算前不同数据类型先转化为同一类型

强制转换

从低到高 (数据类型)变量命

自动转换

自动转换

变量

局部变量–>在方法里的

实例变量–>方法的外面，类的里面，从属于对象

public class Day02 {
     
    String name;
    int age;
    public static void main(String[] args) {
     
        Day02 day02 = new Day02();
        System.out.println(day02.age);
    }
}
//如果不初始化 数值型 默认值 0 0.0
//布尔默认值是 false
//除了基本类型其余都是 null

类变量 stasic

常量

final 常量名=数值

运算符

++a先运算再赋值

a++先赋值再运算

逻辑运算符

与&&---->两个变量都为true，结果为true；

或||---->两个变量有一个为true，结果为true；

非！---->如果为true则变为false，反之；

//短路运算
        int a = 5;
        boolean d = (a<4)&&(a++<4);
        System.out.println(d);
        System.out.println(a);

位运算

//位运算
        /*
                                   A = 0011 1100
                                   B = 0000 1101
        如果2个都为1才为1，否则为0   A&B = 0000 1100
        有一个1就为1               A|B = 0011 1101
        相同则为0，不同则为1        A^B = 0011 0001
        取反                       ~B = 1111 0010
         */

左移<< == *2

右移>> == /2

进制

为了便于理解什么叫2进制，先说说10进制。
我们平时常用的都是10进制，顾名思义，满10进1，
也就是当低位的值够10之后，就在高位上加1，本位变成0。
2进制就是同理，计数时满2进1，
当低位满2之后，就在高位+1，低位变成0。

字符串连接符+

如果+两侧有一侧出现字符串，就会把其他类型都转换成字符串类型连接

注意：运算顺序

	int a = 10;
    int b = 20;
	System.out.println(""+a+b);
	System.out.println(a+b+"");
1020
30

条件运算符

? : ----> x ? y : z

如果x为true，则结果为y,否则为z

优先级问题()

import导包

com.baidu.www

流程控制

Scanner

if选择结构

1. if
2. if……else
3. if……else if……else

选择其中的一个执行，然后跳出程序。但是Java的基础结构为顺序结构

if嵌套结构

switch多选择结构

switch(expression)

	case value:……

		break；

	case value:……

		break；

	case value:……

		break；

	default:……

循环结构

1. while

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mq5tptfs-1613715044162)(笔记图片/while说明.png)]

2. do…while

   do…while循环和while相似，不同的是，do…while循环至少循环一次（先执行再循环，while相反，先判断再循环）

3. 增强型for循环

   int[] numbers = {
          12,55,53,34,88,22};
   for (int n:numbers){
          
       System.out.println(n);
   }
   //将numbers的值赋给n
   

4. for

实例1：

//for循环输出1-1000之间能被5整除的数，每行显示3个
        for (int i = 1  ; i <= 1000; i++) {
     
            if (i % 5 == 0) {
     
                System.out.print(i+"   ");
            }
            if (i%(5*3)==0) {
     
                System.out.println();
            }
        }

实例2：

//打印九九乘法表
for (int i = 1; i <= 9; i++) {
     
            for (int j = 1; j <= i; j++) {
     
                System.out.print(i+"*"+j+"="+(i*j) + "\t");
            }
            System.out.println();
        }

1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

//自己的错误示范   
for (int i = 1; i <= 1; i++) {
     
            int y = 1;
            int sum = y * i;
            System.out.println(i+"*"+y+"="+sum);
        }

        for (int i = 1; i <= 2; i++) {
     
            int e = 2;
            int sum = e * i;
            System.out.print(i+"*"+e+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 3; i++) {
     
            int s = 3;
            int sum = s * i;
            System.out.print(i+"*"+s+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 4; i++) {
     
            int si = 4;
            int sum = si * i;
            System.out.print(i+"*"+si+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 5; i++) {
     
            int wu = 5;
            int sum = wu * i;
            System.out.print(i+"*"+wu+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 6; i++) {
     
            int l = 6;
            int sum = l * i;
            System.out.print(i+"*"+l+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 7; i++) {
     
            int q = 7;
            int sum = q * i;
            System.out.print(i+"*"+q+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 8; i++) {
     
            int b = 8;
            int sum = b * i;
            System.out.print(i+"*"+b+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 9; i++) {
     
            int j = 9;
            int sum = j * i;
            System.out.print(i+"*"+j+"="+sum+"    ");
        }
        System.out.println();

5. break/continue

   break强制退出循环体

   continue退出当前循环并且执行下一次循环

练习：

//打印三角形
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();

}

方法

retun可以结束方法

重载

可变参数

只能有一个，必须放在最后

练习：

//自己写的计算器
public class Demo04 {
     
    public double add(double a,double b){
     
        double sum = a + b;
        return sum;

    }
    public double sub(double a,double b){
     
        double sum = a - b;
        return sum;
    }
    public double mul(double a,double b){
     
        double sum = a * b;
        return sum;
    }
    public double div(double a,double b){
     
        double sum = a / b;
        return sum;

    }

    public static void main(String[] args) {
     
        Demo04 mythod = new Demo04();

        Scanner scanner = new Scanner(System.in);

        for (int i = 1;; i++){
     
        System.out.println("请输入要计算的数字");
        double a = scanner.nextDouble();
        double b = scanner.nextDouble();

        System.out.println("输入计算方法");
        String method = scanner.next();

            switch (method) {
     
                case "+":
                    System.out.println(mythod.add(a, b));
                    break;
                case "-":
                    System.out.println(mythod.sub(a, b));
                    break;
                case "*":
                    System.out.println(mythod.mul(a, b));
                    break;
                case "/":
                    System.out.println(mythod.div(a, b));
                    break;
            }
    }
    }
}

数组

//声明数组
int[]  num01;
//创建数组
array = new int[10]
    
//声明并且创建数组
int[]  array = new int[长度];

//赋值
	int[] num = {
     0,1,2,3,4,5,6,7,8,9};
	num[1] = 1;

数组原则

ArrayIndexOutOfBoundsException数组下标越界异常

长度是确定的

数组中类型必须相同

数组中元素可以是任何类型

数组变量属于引用类型，数组可以看作为对象，数组中每个元素相当于对象的成员变量

数组本身就是对象，Java中对象是在堆中的，因此无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组的使用

public class Demo03 {
     
    public static void main(String[] args) {
     
        int[] array = {
     1,2,3,4,5,6};
        //printArry(array);
        int [] reverse = reverse(array);
        printArry(reverse);


//        for (int i : array) {
     
//            System.out.println(i);
//        }
    }
    //打印数组元素
    public static void printArry(int[] arrays){
     
        for (int i = 0; i < arrays.length; i++) {
     
            System.out.println(arrays[i]);

        }
    }
⭐⭐//反转数组  数组作为返回值
    public static int[] reverse(int[] arrays){
     
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
     
            result[j] = arrays[i];

        }

        return result;
    }
}

多维数组

//循环嵌套输出二维数组
int[][] array = {
     {
     1,2},{
     2,3},{
     3,4},{
     4,5}};
for (int i = 0; i < array.length; i++) {
     
    for (int j = 0; j < array[i].length; j++) {
     
        System.out.print(array[i][j]+"  ");
    }
}

//用增强型for循环输出二维数组
int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        
        System.out.println("输出原始棋盘数组");
        for (int[] ints : array1) {
     
            for (int anInt : ints) {
     
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

Array类

冒泡排序

八大排序之一

//冒泡排序
    public static int[] sort(int[] array) {
     
        int temp = 0;
        //外层循环判断程序跑多少次
        for (int i = 0; i < array.length-1; i++) {
     
            //内层循环，比较两个数的大小
            for (int j = 0; j < array.length-1; j++) {
     
                if (array[j+1]<array[j]){
     
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    return array;
}

稀疏数组

public class Demo08 {
     
    public static void main(String[] args) {
     
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        System.out.println("输出原始棋盘数组");
        for (int[] ints : array1) {
     
            for (int anInt : ints) {
     
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=================================");
//转换为稀疏数组保存

        //获取有效值的个数 便利二维数组
        int sum = 0;
        for (int i = 0; i < 11; i++) {
     
            for (int j = 0; j < 11; j++) {
     
                if (array1[i][j]!=0){
     
                    sum++;
                }
            }
        }
        System.out.println("一共"+sum+"个有效值");
//创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历二维数组，把值赋给稀疏数组
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
     
            for (int j = 0; j < array1[i].length; j++) {
     
               if (array1[i][j]!=0){
     
                   count++;
                   array2[count][0] = i;
                   array2[count][1] = j;
                   array2[count][2] = array1[i][j];
               }
            }
        }
//输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length; i++) {
     
            System.out.println(array2[i][0]+"\t"
                            +array2[i][1]+"\t"
                            +array2[i][2]+"\t");
        }
//还原稀疏数组
        //读取稀疏数组
        int[][] array3 =new int[array2[0][0]][array2[0][1]];
        //还原值
        for (int i = 1; i < array2.length; i++) {
     
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        System.out.println("==================================");
        for (int[] ints : array3) {
     
            for (int anInt : ints) {
     
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

内存

1. 堆：

   存放new的对象和数组

   可以被所有的线程共享，不会存放别的对象引用

2. 栈

   存放基本的变量类型（包含基本类型的具体数值）

   引用对象的变量（存放这个引用在堆里面的具体地址）

3. 方法区

   可以被所有线程共享

   包含了所有的class和static的变量

面向对象编程OOP

本质：以类的方式组织代码，以对象的形式封装数据

抽象 = 共同点

注意：类里面只有属性和方法

※ 特性：

1、封装private ”高内聚 低耦合“---->类的内部数据操作细节自己完成，仅暴露少量的方法给外部使用

​ 属性私有 get/set

2、继承 extends本质是对某一批楼的抽象，从而实现对世界更好的建模(再次抽象)

​ 继承是类与类之间的一种关系（除此之外还有依赖、组合、聚合等），Java中只有单继承没有多继承（一个子类只能有一个父类）

​ public下，子类继承了父类之后就会有父类的全部方法（也可以用private，需设置公共的方法get/set）

​ CTRL + H 查看继承树

​ object类---->Java中所有的类都之间或间接继承object类

​ super

​ 方法重写

3、多态

从代码运行的角度来说，先有类再有对象 类是对象的模板

对象，具体的事物。类，抽象的，对对象的抽象。

构造器

1. 一个类即使什么都不写，它也会存在一个方法==构造器

2. 必须和类的名字相同

3. 必须没有返回值，也不能写void

4. 用来初始化值