歌手爱编程

JAVASE

javase 01：注解

注解的种类：

1.单行注释： //
    
//  单行注释：可以注解一行文字

2.多行注释： /*  */
    
/*
    多行注释：我是多行注释
    多行注释：我是多行注释
    多行注释：我是多行注释
    多行注释：我是多行注释
*/

3.文档注释：/**  */
    
    /**
     * 列表查询
     * @param queryFilter      
     * @return 
     */

说明：文档注释可以加参数，与JavaDoc联合使用（大公司会使用），优秀的开发者代码编写一定规范。

javase02：标识符和关键字

关键字：

abstract     assert         boolean      break         byte
case         catch          char         class         const
continue	 default	    do	         double	       else
enum	     extends	    final	     finally	   float
for	         goto	        if	         implements	   import
instanceof	 int	        interface	 long	       native
new	         package	    private	     protected	   public
return	     strictfp	    short	     static	       super
switch	     synchronized	this	     throw	       throws
transient	 try	        void	     volatile	   while

关键字不能作为名称来引用

标识符：

所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始
首字母之后可以是字母（A-Z或者a-z）、美元符（$）、或者下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的

String Ahello = "chunjun";
String $hello = "chunjun";
String ahello = "chunjun";
String _hello = "chunjun";    1：开始

String _hello = "chunjun";
String $_hello = "chunjun";
String $123hello = "chunjun";
String $$hello = "chunjun";   2：首字母之后

String Hello = "chunjun";
String hello = "chunjun";     4:Hello、hello不一样

javase03 : 数据类型

强类型语言：

要求变量的使用要严格符合规定，所有变量都必须定义后才能使用

String a;
System.out.println(a); //输出错误 没有定义

int num = 10;
System.out.println(num); // 10

java的数据类型分为两大类：

基本类型（Primitive type）：数值类型、boolean类型（八大基本数据类型）

数值类型：整数类型（byte、short、int、long）

浮点类型（float、double）

字符类型（char）

byte：占1个字节范围：-128—127

short：占2个字节范围：-32768—32767

int：占4个字节范围：-2147483648—2147483647 *

long：占8个字节范围：-9223372036854775808—9223372036854775807

float：占4个字节

double：占8个字节 *

char：占2个字节

boolean类型：占1位其值只有true和false两个

//八大基本数据类型
//整数：
byte num1 = 200;//报错 ： 超出128
short num2 =  20;
int num3 = 30;  //最常用
long num4 = 40L; //Long类型在数字之后加个L

//小数：浮点型
float num5 = 20.1f; //float类型在数字之后加F
double num6 = 20.11255478665;

//字符：
char name = 'A';
char name1 = '春峻'; //只能一个字符
char name2 = '春';

//字符串：String不是关键字是一个类
String name3 = "春峻";

//布尔值: 是 非
boolean flag = true;
boolean flag = false;

引用类型：Reference Type

类、接口、数组

位(bit) :是计算机内部数据存储的最小单位，11001100是一个八位二进制数
字节(byte) ：是计算机中数据处理的基本单位，习惯上用大写字母B来表示
1B(byte，字节) = 8bit (位)
字符：是指计算机中使用的字母、数字、字和符号

1bit表示一位
1byte表示一个字节 1B = 8b
1024B = 1KB
1024KB = 1MB
1024MB = 1G
1024G = 1TB

javase04: 数据类型扩展

//整数拓展 ：   进制    二进制0b    十进制    八进制0    十六进制0x

    public static void main(String[] args) {
        int i = 10;
        int i1 = 010;  //八进制0
        int i2 = 0x10; //十六进制0x   0~9  A-F  F=16
        System.out.println(i);  //10
        System.out.println(i1); //8
        System.out.println(i2); //16
    }

//浮点数扩展？ 银行业务怎么表示？  

//float 有限离散  当数据足够大时，浮点数存在舍入误差问题，接近但不等于(四舍五入)
//double
//避免使用浮点数表示   银行用Bigdecimal ---数学工具类
    public static void main(String[] args) {
        float  i = 0.1f;
        double d = 1.0/10;

        System.out.println(i);  // 0.1
        System.out.println(d);  // 0.1
        System.out.println(i==d); // false
        
        float a1 = 232425432653445f;
        float a2 = a1+1;
        System.out.println(a2);  // 2.32425427E14
        System.out.println(a1==a2);  // true
       
        double a1 = 124326452232423424242424.23452;
        double a2 = a1+1;
        System.out.println(a2);  // 1.2432645223242342E23
        System.out.println(a1==a2); // true
    }

//字符拓展

    public static void main(String[] args) {

     char c1 = 'a';
     char c2 = '中';
        System.out.println(c1);  // a
        System.out.println((int)c1);  //强制转换 97
        System.out.println(c2);  // 中
        System.out.println((int)c2);  // 20013
         
        //所有的字符本质都是数字
        //编码 Unicode 码表：65-A 97-a   2 字节  0-65536
        //U0000 UFFFF ——Unicode编码转义表示
        
      char c3 = '\u0061';  \u转义
      System.out.println(c3); //a
  
    }

// 转义字符
// \t  制表符
// \n  换行符


//字符串扩展
    public static void main(String[] args) {
        String sa = "zhangjie";
        String sb = "zhangjie";
        System.out.println(sa==sb);

        String sc = new String("zhangjie");
        String sd = new String("zhangjie");
        System.out.println(sc==sd);
        //对象 从内存分析
        
    }


//布尔值扩展
    
	boolean flag = true;
    if (flag==true){ }   //新手
    if (flag){ }  //老手   //flag==true、flag同一个意思
	 //Less is More!  代码要精简易读

javase05：类型转换

强制类型转换

自动类型转换

*由于java是强类型语言，所以要进行有些运算的时候，需要用到类型转换

低————————————————————————>高：

byte、short、char——> int ——> long——>float——>double

小数的优先级大于整数

    public static void main(String[] args) {
    int i = 129;
    // 强制类型转换  (类型)变量名  高————>低
    byte b = (byte) i;  //  内存溢出
        
        System.out.println(i); // 129
        System.out.println(b); // -127
        
    // 自动类型转换  (类型)变量名  低————>高    
    
        byte a = 125;
        double c = a;
        System.out.println(c);  // 125.0
        
        System.out.println((int) 23.8); // 23
        System.out.println((int)-48.996); // -48
        char d = 'a';
        int e = d+1;
        System.out.println(e); // 98
        System.out.println((char)e); // b
    }

	    /**
     * 注意点：
     * 1 .不能对布尔值进行转换
     * 2 .不能把对象类型转换为不相干的类型
     * 3 .在把高容量转换到低容量的时候，强制转换
     * 4 .转换的时候可能会存在内存溢出，或者精度问题
     */

*运算中，不同类型的数据先转化为同一类型，然后进行运算。

    public static void main(String[] args) {
    //操作比较大的数的时候，注意溢出问题
        // JDK1.7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int year = 20;
        int total = money*year; // 计算的时候溢出了  -1474836480
        System.out.println(total);

        long total2 = money*year;  // 默认是int，转换之前已经存在问题了
        System.out.println(total2);

        long total3 = money*((long)year);
        System.out.println(total3);  // 20000000000
        long total4 = ((long)money)*year;
        System.out.println(total4); // 20000000000
    }

 //F f L l 编写注意统一

javase06:变量、常量、作用域

变量：可以变化的量！

java是一种强类型语言，每个变量都必须声明其类型。

java变量是程序中最基本的存储单位，其要素包括变量名、变量类型、和作用域。

*注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型

变量名必须是合法的标识

变量声明是一条完整的语句，因此每一个声明都必须以分号结束

    public static void main(String[] args) {
        //int a,b,c;
        //int a = 1,b = 2,c = 3;  //程序可读性
        //正确定义变量的格式
        int a = 1;
        int b = 2;
        int c = 3;
        String name = "宋峻峻";
        char x = 'S';
        double pi = 3.14;
    }

变量作用域

类变量

实例变量

局部变量

import java.util.Date;

//类:类里面可以定义 方法 和 属性：变量
public class JavaSE {
    /**
     * 类变量：static
     * 类变量是从属于类的，随着类的消失而消失
     */
    static double salary = 2500;


    /**
     * 实例变量：从属于对象;如果不自行初始化，为该类型默认值
     * 默认值：数值类型： 整数：0 小数：0.0
     * 字符串类型： u0000——>0; 布尔值：false
     * 注：除了基本类型，其余的默认全是null
     */
    String name;
    int age;
    Date birthday;

    //main方法：主程序方法
    public static void main(String[] args) {

        /**
         * 局部变量：必须声明初始化值,只能声明在方法中，随着方法的消失而消亡
         *
         */

        int i = 10;
        System.out.println(i);
        //创建对象：变量类型 变量名 =  new JavaSE();
        JavaSE javaSE = new JavaSE();
        System.out.println(javaSE.age); //初始值 0
        System.out.println(javaSE.name); //初始值 null
        System.out.println(javaSE.birthday); //初始值 null

        //类变量
        System.out.println(salary);

    }
    
    //类里面定义其他方法
    public void add() {

    }

}

常量

常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值

所谓常量可以理解成特殊的变量，它的值被设定后，在程序运行过程中不允许被改变

import java.util.Date;

public class JavaSE {
    //static、final修饰符，不存在先后顺序
    /**
     * 常量：一般用大写字母表示，用final修饰
     */
    //类变量 常量   数据类型
    static final double  PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);

    }

}

变量的命名规范

所有的变量、方法、类名：见名知意

类成员变量：首字母小写和驼峰原则：monthSalary

局部变量：首字母小写和驼峰原则

常量：大写字母和下划线

类名：首字母大写和驼峰原则

方法名：首字母小写和驼峰原则：run()、runRun()；

驼峰规则

1 . 每个单词首字母都要大写：类、接口 UserController MD5Utils

2 . 第一个单词全部小写从第二个开始，每个单词首字母大写：变量、方法等 main findAll

javase07:基本运算符

java语言支持的运算符

算数运算符：【+】【-】【*】【/】【%：取余|模运算】【++】【–】

赋值运算符: 【=】—>【a=10 ：把10赋值给a】

关系运算符: 【>】【<】【>=】【<=】【==】【!= instanceof】

逻辑运算符: 【&&】【||】【！】

位运算符：【&】【|】【^】【~】【>>】【<<】【>>>】

条件运算符：【？：】

扩展赋值运算符：【+=】【-=】【*=】【/=】

代码示例

            //运算符
public class Operator {
    public static void main(String[] args) {
        //二元运算符  IDEA: Ctrl+d ——>复制当前行到下一行
        int a = 10;
        int b = 20;
        System.out.println(a+b);//30
        System.out.println(a-b);//-10
        System.out.println(a*b);//200
        System.out.println(a/b);//0  int类型：只保留整数部分：0
        System.out.println((double) a/b);
        
    }
}

public class Operator {
    public static void main(String[] args) {

        long a = 123112312312313L;
        int b = 123;
        short c = 10;
        byte d = 8;
        char e = 'a';
        double f = 3.14;
        System.out.println(e + f); //100.14 Double
        System.out.println(d + e); //105 Int
        System.out.println(a + b + c + d);//123112312312454 [Long]
        System.out.println(b + c + d);//141 [Int]
        System.out.println(c + d);//18 [Int]

        /**
         * 有Long时，多操作结果类型为Long[自动升为混合运算类型中最高类型]
         * 没有Long时，所有非int类型转化为int类型【无论有没有Int】
         *
         * case：转换
         */
    }
}

public class Operator {
    public static void main(String[] args) {
        //关系运算符返回的结果 ： 正确 、错误  布尔值
        int a = 10;
        int b = 20;
        int c = 21;
        System.out.println(a>b); //false
        System.out.println(a<b); //true
        System.out.println(a==b); //false
        System.out.println(a!=b); //true
        //取余 模运算
        System.out.println(c%a); // c/a = 21/10 = 2....1  【1】
    }
}

javase08：自增自减运算符、初识Math类

自增、自减

一元运算符：比较特殊的运算符【++】【–】

代码示例

public class Operator {
    public static void main(String[] args) {
        //++ -- 自增自减 一元运算符
        int a = 10;

        int b = a++; //a++ : a = a + 1 执行完这行代码后，先给b赋值，在自增
        int c = ++a; //a++ : a = a + 1 执行完这行代码前，先自增，在给b赋值
        System.out.println(a); //12
        System.out.println(b); //10
        System.out.println(c); //12

        //幂运算 2^3 2*2*2 = 8  很多运算，我们会使用一些工具类去操作
        /**
         * Math类中包含很多科学计算提供的方法和常数，
         * 很多特殊运算可以借助于它
         */
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}

javase09：逻辑运算符、位运算符

逻辑运算符代码示例

//逻辑运算符
public class Operator {
    public static void main(String[] args) {
        // 与：【and】 或：【or】 非：【取反】
        boolean a = true;
        boolean b = false;
        System.out.println("a&&b:" + (a && b)); //false【与运算：两个变量都为真，结果为true】
        System.out.println("a||b:" + (a || b)); //true 【或运算：两个变量有一个为真，结果为true】
        System.out.println("!(a&&b):" + !(a && b)); //true 【是真变为假、是假变为真】

        //短路运算:如果短路与运算左边值为false，则直接返回false，不计算右边值
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);
        System.out.println(d); //false
        System.out.println(c); //5
        
    }
}

位运算符代码示例

//逻辑运算符
public class Operator {
    public static void main(String[] args) {
        /**
         A =   0011 1100
         B =   0000 1101
         A&B = 0000 1100 【与：对应位都是1结果为1,否则为0】
         A|B = 0011 1101 【或：对应位都是0结果为0，否则为1】
         A^B = 0011 0001 【异或：两个位置相同为0，否则为1】
         ~B  = 1111 0010 【取反】

         面试题：问 2*8 怎么运算最快？
         2 * 8 = 16  2*2*2*2
         运用位运算：效率极高(二进制)
         <<【左移】: *2
         >>【右移】: /2
            
         0000 0000 0
         0000 0001 1
         0000 0010 2
         0000 0011 3
         0000 0100 4
         0000 1000 8
         0001 0000 16
         */

        System.out.println(2<<3);

    }
}

javase10:三元运算符及小结

public class Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a += b; //a = a + b
        a -= b; //a = a - b
        System.out.println(a);
        //字符串连接符  +
        System.out.println(a+b);
        //面试题：下面两个输出结果如何？【从左到右运算】
        System.out.println(""+a+b); //1020
        System.out.println(a+b+""); //30

        /**
         *  x ? y ： z
         *  如果x==true,则结果为y,否则结果为z
         */
        int Score = 80;
        String score =  Score<60 ?"不及格": "及格";  //必须掌握、开发常用、使代码精简
        System.out.println(score);
    }
}

优先级：

1   ()、[]、{}	
2	!、+、-、~、++、--	
3	*、/、%	
4	+、-	
5	«、»、>>>	
6	<、<=、>、>=、instanceof	
7	==、!=	
8	&	
9	^	
10	|	
11	&&	
12	||	
13	?:	
14	=、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>=

javase11:包机制

包机制的理解

*为了更好的组织类、java提供了包机制、用于区别类名的空间

*包语句的语法格式： 【相当于文件夹】

package com.jun.base;

*一般利用公司域名倒置作为包名：www.baidu.com 【com.baidu.www】

为了能够使用某一个包的成员，我们需要在java程序中明确导入该包。使用*“import”**语句可以完成此功能

import java.util.List;
import java.util.* //导入这个包下的所有的类

参考书籍：阿里巴巴开发手册【全网】

javase12：javaDoc生成文档

javadoc命令是用来生成自己API文档的
参数信息：
@author 作者名
@version 版本号
@since 指明需要最早使用的JDK版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

加在类上面就是类注释、加在方法上面就是方法注释

package com.jun.base;

/**
 * 1. 定义在类上
 *
 * @author SC_JUN
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

    /**
     * 2. 定义在方法上
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String fun(String name) throws Exception {
        return name;
    }
}

命令行生成javaDoc文档

类Operator——>show in Explorer——>CMD
命令行：javadoc -encoding UTF-8 -charset UTF-8 Operator.java 【类名.后缀】
//命令行下编译，加上-encoding参数，即javadoc -encoding UTF-8....编译格式定为UTF-8
//-charset UTF-8指定字符集编码为UTF-8

IDEA生成javaDoc文档

选择需要生成文档的代码-->Toos——>Generate javaDoc——>Output directory【输出路径】——>
Othercommand line arguments:-encoding UTF-8 -charset UTF-8

javase13：流程控制【一】

用户交互Scanner

**Scanner实现程序与人的交互，在java中我们可以使用一个工具类，**获取用户的输入。【java.util.Scanner】**是java5新特性。**我们可以通过Scanner类来获取用户的输入

基本语法

Scanner scanner = new Scanner(System.in);

通过Scanner类的 next() 与nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据

package com.jun.base;
import java.util.Scanner;

public class Base {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收："); // feng liu

        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            String str = scanner.next();
            System.out.println("输入的内容为："+str); // feng
        }
        scanner.close(); //节省资源 属于io流的东西不关闭会一直占用资源
    }
}

package com.jun.base;
import java.util.Scanner;

public class Base {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接收：");  // feng liu

        //判断用户有没有输入字符串
        if(scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输入的内容为："+str); //fengliu
        }
        scanner.close(); //节省资源 属于io流的东西不关闭会一直占用资源
    }
}

next（）与 nextLine（）区别

        /**
         * next():
         * 一定要读取到有效字符后才可以结束输入
         * 对输入有效字符之前遇到的空白，next()方法会自动去掉
         * 只有对输入有效字符后才将其后面输入的空白作为分隔符或者结束符
         * next()不能得到带有空格的字符串
         * 
         * nextLine()：
         * 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
         * 可以获得空白
         */

Scanner进阶使用

package com.jun.base;
import java.util.Scanner;

public class Base {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //从键盘接收数据
        int i =0;
        float f = 0.0f;

        System.out.println("请输入整数：");
        if(scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据："+i);
        }else{
            System.out.println("输入的不是整数数据！");
        }


        System.out.println("请输入小数：");
        if(scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+f);
        }else{
            System.out.println("输入的不是小数数据！");

        }
        scanner.close();
    }
}

代码练习

package com.jun.base;
import java.util.Scanner;

public class Base {
    public static void main(String[] args) {
        //输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
        Scanner scanner = new Scanner(System.in);
        //和
        double sum = 0;
        //输入数字的个数
        int m = 0;
        
        System.out.println("请输入数字：");
        //通过循环判断是否还有输入，并在里面对每一次进行求和统计
        while (scanner.hasNextDouble()) {  // 省略：scanner.hasNextDouble()：老手？新手
            double i = scanner.nextDouble();
            m++;  // m = m + 1
            sum += i;  // sum = sum + i
            System.out.println("你输入了第"+m+"个数据,当前结果为"+sum);
        }
        System.out.println(m+"个数的和"+sum);
        System.out.println(m+"个数的平均值"+(sum/m));

        scanner.close();
    }
}

javase14：流程控制【二】

顺序结构

java的基本结构就是顺序结构，除非特别指明，否则就按顺序一句一句执行

顺序结构是最简单的算法结构

语句与语句之间，框与框之间是按从上到下的顺序进行的，顺序结构是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构

package com.jun.base;

public class Base {
    public static void main(String[] args) {
        System.out.println("宋春峻");
        System.out.println("贺伟娜");
        System.out.println("SLS");
        System.out.println("自媒体");
    }
}

选择结构

if单选择结构

我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示

 //语法：       if(布尔表达式){
            //布尔表达式为true将执行的代码
        }
******************************************************************************
package com.jun.base;
import java.util.Scanner;

public class Base {
    public static void main(String[] args) {
        Scanner scanner =  new Scanner(System.in);
        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        //equals：判断字符串是否相等
        if(s.equals("JUN")){
            System.out.println(s);
        }
        System.out.println("输出结束！");
    }
}

if双选择结构

//语法：if(布尔表达式){
   //布尔表达式为true执行的代码
}else{
   //布尔表达式为false执行的代码
}
*****************************************************************************
    package com.jun.base;

import java.util.Scanner;

public class Base {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        //equals：判断字符串是否相等
        if (score >= 60) {
            System.out.println("成绩合格!");
        } else {
            System.out.println("成绩不合格、仍需努力！");
        }
    }
}

if多选择结构

//语法：

if(布尔表达式1){
   //布尔表达式1为true执行的代码
}else if(布尔表达式2){
   //布尔表达式2为true执行的代码
}else if(布尔表达式3){
   //布尔表达式3为true执行的代码
}else{
   //以上布尔表达式都不为true执行的代码
}
*************************************************************************
    package com.jun.base;

import java.util.Scanner;

public class Base {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        //equals：判断字符串是否相等
        if (score == 100) {
            System.out.println("恭喜满分！!");
        } else if (score < 100 && score >= 90) {
            System.out.println("A级！");
        } else if (score < 90 && score >= 80) {
            System.out.println("B级！");
        } else if (score < 80 && score >= 70) {
            System.out.println("C级！");
        } else if (score < 70 && score >= 60) {
            System.out.println("D级！");
        } else if (score < 60 && score >= 0) {
            System.out.println("成绩不及格！");
        } else {
            System.out.println("成绩不合法！");
        }
    }

}
    /**
     * IF语句至多有一个else语句、else语句在所有else if语句之后
     * IF语句可以有若干个else if语句、else if语句必须在else语句之前
     * 一旦其中一个else if 语句为true，其他的else if语句都将跳过执行
     */

嵌套的if结构

使用嵌套的if…else是合法的。相当于可以在另一个if 或者 else if语句中使用 if或者else if语句。

//语法：
if(布尔表达式1){
    //布尔表达式1为true执行的代码
}(布尔表达式2){
    //布尔表达式2为true执行的代码
	}
******************************************************************************
    //思考：寻找一个数、在1-100之间

所有的流程控制语句都可以相互嵌套互不影响

switch多选择结构

多选择结构还有一种实现方式就是 switch case 语句

switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

switch 语句中的变量类型可以是：

byte、short、int、char

从Java SE 7 开始

switch 支持字符串String类型了

同时case标签必须为字符串常量或字面值

//语法：
switch(expression){
    case value :
        //语句
        break; //可选
    case value :
        //语句
        break; //可选
//可以有任意数量的case语句
    default: //可选
        //语句
}
******************************************************************************

    package com.jun.base;

import java.util.Scanner;

public class Base {
    public static void main(String[] args) {

        /**
         * 输出结果：及格
         *         再接再厉
         *         挂科
         * 发生case穿透问题  switch匹配一个具体的值
         * 写完一个语句后面都要加break匹配成功后会终止switch语句，否则发生case穿透问题
         */
        char grade = 'C';
        switch (grade) {
            case 'A':
                System.out.println("优秀");
                break; //可选
            case 'B':
                System.out.println("良好");

            case 'C':
                System.out.println("及格");

            case 'D':
                System.out.println("再接再厉");

            case 'E':
                System.out.println("挂科");
            default:
                System.out.println("未知等级");

        }

    }
}

package com.jun.base;


public class Base {
    public static void main(String[] args) {
        String name = "峻峻";
        //JDK7的新特性，表达式结果可以是字符串
        //字符的本质还是数字
        /**
         *编译 java---class(字节码文件)
         * 反编译【工具：IDEA】：calss(字节码文件)---java
         */
        switch (name) {
            case "峻峻":
                System.out.println("峻峻");
                break;
            case "JJ":
                System.out.println("JJ");
                break;
            case "迈克尔杰克逊":
                System.out.println("迈克尔杰克逊");
                break;
            default:
                System.out.println("啥也不是！！");
        }
    }
}

//反编译文件：Project Settings--Project--Project compiler output 将输出路径的.class文件放到java编译的.class文件中、IDEA会自动反编译文件

// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.jun.base;

public class JAVASE {
    public JAVASE() {
    }

    public static void main(String[] args) {
        String name = "峻峻";
        byte var3 = -1;
        switch(name.hashCode()) {
        case -12275714:
            if (name.equals("迈克尔杰克逊")) {
                var3 = 2;
            }
            break;
        case 2368:
            if (name.equals("JJ")) {
                var3 = 1;
            }
            break;
        case 761696:
            if (name.equals("峻峻")) {
                var3 = 0;
            }
        }

        switch(var3) {
        case 0:
            System.out.println("峻峻");
            break;
        case 1:
            System.out.println("JJ");
            break;
        case 2:
            System.out.println("迈克尔杰克逊");
            break;
        default:
            System.out.println("啥也不是！！");
        }

    }
}

看源码

javase15：流程控制【三】

while 循环

while是最基本的循环，结构为

while(布尔表达式){
    //循环内容
}

只要布尔表达式为true，循环就会一直执行下去

大多数情况是会让循环停止下来的，需要一个让表达式失效的方式来结束循环

少部分情况需要循环一直执行【服务器的请求、响应、监听】等

循环条件一直为true会造成无限循环【死循环】，正常的业务编程中应避免死循环【影响程序性能】

思考题：1 + 2 + 3 + … + 100 = ?

package com.jun.base;

public class JAVASE {
    public static void main(String[] args) {
        // 输出0-100
        int i = 0;
        while (i <= 100) {
            System.out.println(i);
            i++;
        }
        /**
         * int i = 0;
         * while(true){
         *     System.out.println(i);
         * }
         * 死循环：等待客户端连接
         */
        
    }
}

package com.jun.base;
public class JAVASE {
    public static void main(String[] args) {
        // 1 + 2 + 3 + ... + 100 = ?
        int i = 0;
        int sum = 0;
        while (i <= 100) {
            sum += i;
            i++;
        }
        System.out.println(sum);

    }
}

do…while循环

while语句如果不满足条件，则不能进入循环，但有时候我们需要即使不满足条件，也至少执行一次。

do…while循环和while循环相似，不同的是，do…while循环至少会执行一次

//do...while 循环结构:

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

while循环和do…while循环的区别：

while循环先判断后执行

do…while循环总是保证循环体会被至少执行一次！【主要差别】

package com.jun.base;

public class JAVASE {
    public static void main(String[] args) {
        int i = 0 ;
        while (i < 0) {
            System.out.println(i);
            i++;
        }
        System.out.println("======================================================");
        do{
            System.out.println(i);
        }while (i<0);
    }
}

for循环**

虽然所有的循环结构都可以用while和do…while表示，但Java提供了另一种语句—for循环，使一些循环结构变得更加简单。

for循环语句是支持迭代的一种通用结构，是【最有效、最灵活】的循环结构。

for循环执行的次数是在执行前就确定的。语法格式如下

for(初始化;布尔表达式;更新){
    
    //代码语句
}

练习1：计算 0 — 100 之间的奇数和偶数的和

练习2：用while或for循环输出1—1000之间能被5整除的数，并且每行输出三个

练习3：打印九九乘法表

package com.jun.base;

public class ForDemo01 {
    public static void main(String[] args) {
        int a = 1; //初始化条件
        while (a <= 100) { //条件判断
            System.out.println(a); //循环体
            a += 2; //迭代

        }
        System.out.println("while循环结束！！");

        /**
         * 所有的for循环都可以用while代替
         * for循环更加高效
         *
         * 更新=迭代
         */
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
        System.out.println("for循环结束！！");

        /**
         * 快捷键：100.for
         * 
         * for循环说明：
         * 最先执行初始化步骤。可以声明一种类型，也可以初始化一个或多个循环控制变量，也可以是空语句。
         * 然后检测布尔表达式的值。如果为true循环体被执行，如果为false，循环终止，开始执行循环体后面的语句。
         * 再次检测布尔表达式，循环执行上面的过程
         * 
         * for死循环：
         * 
         * for( ; ; ){
         *     
         * }
         * 
         */
         
        
    }
}

package com.jun.base;

public class ForDemo01 {
    public static void main(String[] args) {
        // 练习 1 ：计算 0 到 100之间的奇数和偶数的和
        int oddsum = 0;
        int evenSum = 0;
        for (int i = 0; i < 100; i++) {
            if(i%2!=0){
                oddsum += i;
            }else {
                evenSum += i;
            }
        }
        System.out.println("奇数的和"+oddsum);
        System.out.println("偶数的和"+evenSum);
        System.out.println(oddsum+evenSum);
    }
}
******************************************************************************
    package com.jun.base;

public class ForDemo02 {
    public static void main(String[] args) {
    //练习2：用while或for循环输出1—1000之间能被5整除的数，并且每行输出三个
        for (int i = 0; i < 1000; i++) {
            if (i%5==0){
                System.out.print(i+"\t");
            }
            if(i%(3*5)==0){ //换行
                System.out.println();
                //System.out.print("\n");
            }
        }
        /**
         * println 输出完会换行
         * print 输出完不会换行
         */

    }

}
******************************************************************************
    package com.jun.base;

public class ForDemo02 {
    public static void main(String[] args) {
        //练习3：打印九九乘法表
        /**
         * 步骤：
         * 1:  打印第一列
         * 2： 把固定的1在用一个循环包起来
         * 3： 去掉重复项 i<=j
         * 4:  调整样式
         */
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            System.out.println();
        }
    }
}

Java5中引入了一种主要应用于数组、集合对象的增强型For循环

//语法格式

for(声明语句：表达式){
    
    //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

package com.jun.base;

public class ForDemo02 {
    public static void main(String[] args) {
        int[] number = {10, 20, 30, 40, 50};
        //普通for循环输出数组元素
        for (int i = 0; i < 5; i++) {
            System.out.println(number[i]);
        }
        System.out.println("=======================================");
        //遍历数组的元素
        for (int i : number) {
            System.out.println(i); //10 20 30 40 50
        }
    }

}

break、continue、goto

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）

continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

goto是Java的一个保留字，未得到使用。【标签的写法：label—>中断到标签的地方】

//Break：
package com.jun.base;

public class BreakDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i < 100) {
            i++;
            System.out.println(i);
            if (i == 30) {
                break;
            }
        }
        System.out.println("123");
    }

}

//continue：
package com.jun.base;

public class ContinueDemo {
    public static void main(String[] args) {
        /**
         * break和continue区别
         * break：在任何循环的主体部分，均可用break控制循环流程。break用于强行退出循环，
         * 不执行循环中剩余的语句(可以在switch语句中使用)
         * 
         * continue：用在循环语句体中用于终止某次循环过程，即跳过循环体中尚未执行的语句
         * 接着进行下一次是否执行循环的判定
         * 
         * 例如：调休和离职
         */
        int i = 0;
        while (i < 100) {
            i++;
            if (i % 10 == 0) {
                System.out.println();
                continue;
            }
            System.out.println(i);
        }
    }

}

//goto：
package com.jun.base;

public class LabelDemo {
    public static void main(String[] args) {
        //打印101-150之间的所有质数
        //质数：在大于1的自然数中，除了1和它本身以外不在有其他因数的自然数
        int count = 0;
        outer:
        for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0) {
                    continue outer;
                }
            }
            System.out.print(i+"\t");
        }

    }
}

javase16：流程控制练习题

package com.jun.base;

public class TextDemo {
    public static void main(String[] args) {
        //打印三角形 5行
        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();
        }
    }
}
Debug: 自己分析、理解

javase17：方法01

System.out.println() 的理解

调用系统类里面的标准输出对象out中的println方法

java方法是语句的集合，他们在一起执行一个功能

方法是解决一类问题步骤的有序组合

方法包含于类或对象中

方法在程序中被创建，在其他地方被引用

方法设计的原则

方法的本意是功能块，就是实现某个功能语句块的集合。在设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于后期扩展。

回顾

方法的命名规则：首字母小写后面是驼峰命名

代码示例

package com.jun.base;

public class Demo01 {
    public static void main(String[] args) {
        test();
    }

    public static int add(int a, int b) {
        return a + b;
    }

    /**
     * 没学对象之前，用static修饰，方便调用
     */
    public static void test() {
        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();
        }
    }
}

javase18：方法02

方法的定义

java的方法类似于其他语言的函数，是一段用来完成待定功能的代码片段，一般情况下，定义一个方法包含以下语法：

//语法：
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
        return 返回值
}

**方法包含一个方法头和方法体。**下面是一个方法的所有部分：

**修饰符：**修饰符，是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型，有些方法执行所需的操作但没有返回值。无返回值时returnValueType是关键字void.

**方法名：**是方法的实际名称。方法名和参数表共同构成方法签名。

**参数类型：**参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数类型指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数

形式参数：在方法被调用时用于接收外部输入的数据

实参：调用方法时，实际传给方法的数据

方法体: 方法体包含具体的语句，定义该方法的功能

代码示例

package com.jun.base;

public class Demo01 {
    public static void main(String[] args) {
        //实际参数：实际调用传递给方法的参数
        int add = add(3, 4);
        System.out.println(add);
    }
        //形式参数，用来定义作用的
    public static int add(int a, int b) {
        return a + b;
    }

    /**
     * 没学对象之前，用static修饰，方便调用
     */
}

方法的调用

调用方法：对象名.方法名（实参列表）

java支持两种调用方法的方式【根据方法是否返回值来选择】

1 .当方法返回一个值的时候，方法调用通常被当作一个值，例如：

int larger =max(30,40);

2. 当方法返回值是void，方法调用一定是一个语句

System.out.println("Hello JunJun !")

代码演示：

package com.jun.base;

public class Demo02 {
    public static void main(String[] args) {
        int max = max(4, 5);
        System.out.println(max);
    }

    //比大小
    public static int max(int num1, int num2) {
        int result = 0;
        if (num1 == num2) {
            System.out.println("num1==num2");
            return 0; // 终止方法： 通过return终止调用
        }
        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;

        }
        return result;
    }

}

扩展：值传递（java）和引用传递*

javase19：方法03

方法重载

重载：在一个类中，有相同的函数名称，但形参不同的函数【方法名相同，参数列表不同】

方法重载的规则：

*方法名称必须相同

*参数列表必须不同（个数不同，类型不同，参数排列顺序不同等）

方法的返回类型可以相同也可以不相同

仅仅返回类型不同不足以成为方法重载

实现理论：

方法名称相同时编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败编译器会报错。

//示例：
public static int max(double num1, double num2) {...}
public static int max(int num1, int num2) {...}
public static int max(int num1, int num2,int num3) {}

命令行传参

有时候你希望运行一个程序的时候在传递给他消息。这要靠传递命令行参数给main()函数实现

package com.jun.base;
public class CommandLine {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]:" + args[i]);
        }
    }
}
****************************************************************************** 
DOS命令：
D:\workspace\JAVASE\src\com\jun\base>javac CommandLine.java
D:\workspace\JAVASE\src>java com.jun.base.CommandLine
D:\workspace\JAVASE\src>java com.jun.base.CommandLine this is SongChunJie
args[0]:this
args[1]:is
args[2]:SongChunJie

可变参数

JDK1.5开始，java支持传递同类型的可变参数给的一个方法。

在方法声明中，在指定类型参数后加一个省略号(…)。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

package com.jun.base;

public class Demo04 {
    public static void main(String[] args) {
        //调用可变参数的方法【本质是数组】
        printMax(34, 25, 56, 22, 2, 15); //传递可变参数
        printMax(new double[]{1, 2, 3}); //传递数组
    }

    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        //排序！
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] > result) {
                result = numbers[i];
            }
        }
        System.out.println(result);
    }
}

递归【面试高频】

A方法调用B方法【容易理解】

递归：A方法调用A方法【自我调用】

利用递归可以用简单的程序来解决复杂的问题。通常把一个复杂的问题层层转化为一个与原问题相似的、规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构的两个部分：

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环

递归体：什么时候需要调用自身方法

package com.jun.base;
public class Demo06 {
    public static void main(String[] args) {
        /**
         * 阶乘：
         * 2! : 2*1
         * 3! : 3*2*1
         * 5！: 5*4*3*2*1
         */
        System.out.println(a(5));
    }

    public static int a(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * a(n - 1);
        }
    }
}

理解递归

画图工具：Win+R【mspaint】

练习

写一个计算器，要求实现加减乘除功能，并且能够实现循环接收新的数据，通过用户交互实现

思路推荐：

写四个方法：加减乘除

利用循环+switch进行用户交互

传递需要操作的两个数

输出结果

package com.jun.base;
import java.util.Scanner;
public class Demo08 {
    /**
     * 写一个计算器，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交互实现。思路推荐：
     * 1. 写4个方法：加减乘除
     * 2. 利用循环+switch进行用户交互
     * 3. 传递需要操作的两个数
     * 4. 输出结果
     */
    public static void main(String[] args) {
        while (true) {
            System.out.println("请输入运算类型之一,运算类型包括【+、-、*、/】");
            Scanner scanner = new Scanner(System.in);
            String operator = scanner.next();
            if (operator.equals("quit")) {
                System.out.println("退出当前计算器");
                break;
            } else {
                System.out.println("请输入计算的两个数,输入一个数按回车,在输入另一个数");
            }
            Scanner scanner1 = new Scanner(System.in);
            Double a = scanner1.nextDouble();
            Scanner scanner2 = new Scanner(System.in);
            Double b = scanner2.nextDouble();

            double result = 0;
            switch (operator) {
                case "+":
                    result = add(a, b);
                    break;
                case "-":
                    result = sub(a, b);
                    break;
                case "*":
                    result = mul(a, b);
                    break;
                case "/":
                    result = div(a, b);
                    break;
                default:
                    System.out.println("请重新输入");
            }
            System.out.println(a + operator + b + "=" + result);
        }

    }


    public static double add(double a, double b) {
        return a + b;
    }

    public static double sub(double a, double b) {
        return a - b;
    }

    public static double mul(double a, double b) {
        return a * b;
    }

    public static double div(double a, double b) {
        return a / b;
    }
}

javase20：数组01

数组定义

数组是相同类型数据的有序集合

数组描述的是相同类型的若干个数据按照一定的先后次序排列组合而成

每个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

数组声明创建

首先必须声明数组变量，才能在程序中使用数组

//声明数组语法

dataType[] arrayRefVar ;  //首选的方式
或
dataType arrayRefVar[] ;  //效果相同、不是首选

java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的、数组索引从0开始

获取数组长度： arrays.length

package com.jun.array;
import java.sql.SQLOutput;
public class ArrayDemo01 {
    //变量类型 变量名字 变量值
    public static void main(String[] args) {
        int[] nums;  //定义方式 java风格  1.声明一个数组
        int nums1[];  //C、C++风格【了解】
        nums = new int[10];  //2.存放十个int类型的数字 在内存里开辟十个空间用来存放数字
        //3.给数组元素赋值
        nums[0] = 1;
        nums[2] = 5;
        nums[3] = 6;
        nums[4] = 4;
        nums[5] = 2;
        nums[6] = 3;
        nums[7] = 7;
        nums[8] = 8;
        nums[9] = 10;
        System.out.println(nums[8]);
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum  = sum + nums[i];
        }
        System.out.println(sum);
    }
}

javase21：数组02

内存分析

	Java内存分析
堆	栈	方法区

堆：存放new的对象和数组

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

栈：存放基本变量类型(会包含这个基本类型的具体数值)

引用对象的变量(会存放这个引用在堆里面的具体地址)

方法区：可以被所有线程共享

包含了所有的class和static变量

//代码示例
     // 1.声明数组
     int[] array = null;  //此时在栈中存放
     // 2.创建数组
     array = new int[3]; //在堆中开辟了内存，内存占了十个大小空间【创建对象】
     // 3.给数组元素赋值
     array[0]= 1;
     array[1]= 4;
     array[2]= 7;
     array[3]= 9;

数组三种初始化

静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化

int[] a = new int[2] ;
a[0] = 1;
a[1] = 2;

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

package com.jun.array;
public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化：  创建+赋值
        int[] a = {12, 21, 12, 12, 12, 15};
        System.out.println(a[0]);
        //动态初始化: 包含默认初始化
        int[] b = new int[5];
        b[0] = 10;
        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
    }
}

下标越界及小结

数组的特点：

//数组长度确定、一旦被创建其大小不可被改变
//数组元素必须是相同类型、不允许出现混合类型
//数组中元素可以是任何数据类型、包括基本类型和引用类型
//数组变量属于引用类型、数组也可以看成对象，数组中的每个元素相当于该对象的成员变量
//数组本身就是对象、java中对象是存在堆中的、因此数组无论是保存原始类型还是其他对象类型、数组对象本身是在堆中的

数组边界：

//下标的合法区间：[0,length-1]、如果越界就会报错;
public static void main(String[] args){
    int[] a = new int[2];
    System.out.println(a[2]);
}

ArrayIndexOutOfBoundsException:数组下标越界异常！

小结：数组长度如果越界【超出指定长度】、则报：ArrayIndexOutOfBounds

javase22：数组03

数组的使用

普通For循环、For-Each循环

package com.jun.array;
public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        //打印全部的数组元素
        for (int i = 0; i <= array.length - 1; i++) {
            System.out.println(array[i]);
        }
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println("sum="+sum);

        //查找最大元素
        int Max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i]>Max){
                Max=array[i];
            }
        }
        System.out.println("Max="+Max);
        /**
         * For-Each:
         * JDK1.5以上 【无下标】
         */
        for (int a : array) {
            System.out.println(a);
        }
    }
}

数组作方法入参

数组做返回值

package com.jun.array;
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {10, 20, 30, 50, 60};
        printArray(arrays);
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i] + " ");
        }
    }

    public static int[] reverse(int[] arrays) {  //反转：reverse
        int[] result = new int[arrays.length];
        for (int i = 0, j = arrays.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

二维数组

//定义二维数组a、可以看作一个两行五列的数组
int[][] a = new int[2][5];
*****************************************************************************************
package com.jun.array;
public class ArrayDemo05 {
    public static void main(String[] args) {
        /**
         *  [3][2]:
         *  2,5 arrays[0]
         *  3,4 arrays[1]
         *  5,6 arrays[2]
         */
        int arrays[][] = {{2, 5}, {3, 4}, {5, 6}};
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.println(arrays[i][j]);
            }
        }
        
        printArray(arrays[0]);
        System.out.println(arrays[0][1]);
    }

    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i] + " ");
        }
    }
}

思考：多维数组的使用？？？

javase23：数组04

Arrays类

数组的工具类：java.util.Arrays

数组对象本身并没有什么方法供我们调用、但API中提供了工具类Arrays、从而可以对数据对象进行一些基本操作

查看JDK帮助文档

Arrays类中的方法都是用static修饰的静态方法、使用时可以直接使用类名调用、而 "不用"对象来调用【注：是不用、而不是不能】

Arrays常用功能

给数组赋值：通过fill方法

对数组排序：sort方法、按升序

比较数组：通过equals方法比较数组中元素值是否相等

查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

package com.jun.array;
import java.util.Arrays;
public class ArrayDemo06 {
    public static void main(String[] args) {
        /**
         * Arrays类：—>structure【查看类中所有方法】
         */
        int[] a = {1,2,3,4,555,68,5484,4561611,48,464,48949};
        System.out.println(a);  //[I@135fbaa4

        //打印数组元素 Arrays.toString
        System.out.println(Arrays.toString(a));

        //数组排序:升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //数组填充
        Arrays.fill(a,2,4,5);
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

冒泡排序无疑是最为出名的排序算法之一、总共有八大排序！

冒泡的代码还是相当简单的、两层循环、外层冒泡轮数，里层依次比较、江湖中人人尽皆知！

我们看到嵌套循环、应该立马就可以得出这个算法的时间复杂度为O(n^2)

思考：如何优化？？？

package com.jun.array;
import java.util.Arrays;
public class ArrayDemo06 {
    public static void main(String[] args) {
        /**
         *  冒泡排序：
         *     1.比较数组中，两个相邻的元素，如果第一个数比第二个数大、则交换他们的位置！
         *     2.每一次比较，都会产生出一个最大、或者最小的数字！
         *     3.下一轮则可以少一次排序！
         *     4.依次循环直到结束！
         */
        int[] array = {5, 8, 4, 6, 90, 3};
        int[] sort = sort(array);
        System.out.println(Arrays.toString(array));
    }

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;
        boolean flag = false;  //通过flag表示减少没有意义的比较

        //外层循环、判断循环轮数有多少次！【轮数 =数组长度-1】
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环、比较判断两个数、如果第一个数比第二个数大、则交换位置 【】
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {   // >:从大到小 | <:从小到大
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }

            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时、可以使用稀疏数组来保存该数组。

稀疏数组的处理方式：

记录数组一共几行几列、有多少不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中、从而缩小程序的规模

//原始数组                                         
0   0   0   22   0   0    15                 
0   11  0   0    0   17   0
0   0   0   -6   0   0    0
0   0   0   0    0   39   0
91  0   0   0    0   0    0
0   0   28  0    0   0    0 
    
//稀疏数组
     行   列   值 
[0]  6    7    8
[1]  0    3    22
[2]  0    6    15
[3]  1    1    11
[4]  1    5    17
[5]  2    3    -6
[6]  3    5    39
[7]  4    0    91
[8]  5    2    28

package com.jun.array;

public class ArrayDemo07 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11  0：没有棋子  1：黑棋  2：白棋
        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();
        }
        //转换为稀疏数组保存
        // 1.获取有效值个数
        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);

        // 2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        // 3.遍历二维数组、将非零的值、存放稀疏数组中
        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];
                }
            }
        }
        // 4.输出稀疏数组
        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");
        }

        // 1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        // 2.给其中元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        // 3.打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

javase24：面向对象01

面向对象

java的核心思想就是OOP【面向对象编程】

面向对象 & 面向过程

面向过程：

步骤清晰简单、第一步做什么、第二步…

面向过程适合处理一些简单的问题

面向对象：

物以类聚、分类的思维模式思考问题时首先会想解决问题需要哪些分类、然后对这些分类进行单独思考。
最后对某个分类下的细节进行面向过程的思索

*面向对象适合处理复杂的问题、适合处理需要多人协作的问题

*对于描述复杂的事物、为了从宏观上把握、从整体上合理分析、则需要使用面向对象的思路来分析整个系统。
但是具体到微观操作、仍然需要运用面向过程的思路去处理

什么是面向对象：

面向对象编程(Object-oriented Programming,OOP)

*面向对象编程的本质就是：以类的方式组织代码、以对象的组织(封装）数据

抽象

编程思想、持续的学习！

三大特性

封装

继承

多态

从认识论角度考虑是先有对象后有类。对象、是具体的事物。类是抽象的、是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板

方法的回顾

方法的定义

修饰符返回值类型

package com.jun.oop;
//Demo01 类
public class demo01 {
    //main 方法
    public static void main(String[] args) {
    }
    /**
     * 方法：
     * 修饰符 返回值类型 方法名(...){
     *  //方法体
     *     return 返回值;
     *     }
     */
    //return表示结束方法、返回一个结果【void：返回值可以为空】
    public String sayHello(){
        return "helloJun!";
    }
    public int max(int a,int b){
        return a>b ? a:b;
    }
}

break和return的区别

break：跳出switch代码块、结束循环

return表示结束方法、返回一个结果

方法名

驼峰见名知意

参数列表

(参数类型、参数名) …

异常抛出：？？【以后】

方法的调用：递归

静态方法、非静态方法

package com.jun.oop;
//学生类
public class Student {
    //静态方法
    public static void say(){
        System.out.println("学生发言");
    }
    //非静态方法
    public void run(){
        System.out.println("学生跑步");
    }
}
*****************************************************************************************
package com.jun.oop;
public class Demo02 {
    public static void main(String[] args) {
        //静态方法 static
        Student.say();
        //非静态方法
        //实例化类 new
        //对象类型 对象名 = 对象值
        Student student = new Student();
        student.run();
    }

    //static 和类一起加载的
    public static void a() {
          b();//静态方法调用非静态方法出错
    }
     //类实例化之后才存在
    public void b() {
    }
}

形参和实参

package com.jun.oop;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数的类型要对应！
        int add = Demo03.add(1, 2);
        System.out.println(add);
    }

    public static int add(int a, int b) {
        return a + b;
    }
}

值传递和引用传递

package com.jun.oop;
public class Demo04 {
    public static void main(String[] args) {
        //值传递
        int a = 1;
        System.out.println(a); // 1
        Demo04.change(a);
        System.out.println(a); // 1
    }
    //返回值为空
    public static void change(int a) {
        a = 10;
    }
}
*****************************************************************************************
package com.jun.oop;
public class Demo05 {
    public static void main(String[] args) {
        //引用传递： 对象、本质还是值传递
        Person person = new Person();
        System.out.println(person.name); //null
        Demo05.change(person);
        System.out.println(person.name);  //宋春峻
    }

    public static void change(Person person) {
        /**
         * person是一个对象： 指向 ————>Person person = new Person();
         * 这是个具体的人、可以改变属性
         */
        person.name = "宋春峻";
    }
}

//定义一个Person类、有一个属性：name
class Person {
    String name; //null

}

this关键字【转到继承】

javase25：面向对象02

类与对象的关系

类是一种抽象的数据类型、它是对某一类事物的整体描述/定义、但是并不能代表一类具体的事物

动物、植物、手机、电脑 …

Person、Pet类、Car类等、这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例

宋春峻就是人的一个具体实例、宋春峻家里的旺财就是狗的一个具体实例

能够体现出特点、展现出功能的是具体的实例、而不是一个抽象的概念

创建与初始化对象

*使用new关键字创建对象

使用new关键字创建的时候、除了分配内存空间之外、还会给创建好的对象进行默认的初始化以及对类中构造器的调用

类中的构造器也称为构造方法、是在进行创建对象的时候必须要调用的、而且构造器有以下两个特点：

必须和类的名字相同
必须没有返回类型、也不能写void

*构造器必须要掌握

package com.jun.oop.Demo02;
//学生类
public class Student {
    //属性【字段】
    String name; // null
    int age;     // 0
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}
//学程序好 —— 【对世界进行更好的建模！】
*****************************************************************************************
package com.jun.oop.Demo02;
//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        /**
         * 类：本身是抽象的、需要被具体的实例化！
         * 通过new关键字实例化、类实例化后会返回一个自己的对象！
         * student对象就是一个Student类的具体实例！
         */
        Student chunjun = new Student();
        Student weina = new Student();
        chunjun.name = "宋春峻";
        chunjun.age = 23;
        weina.name = "贺伟娜";
        weina.age = 23;
        System.out.println(chunjun.name);  
        System.out.println(chunjun.age);
        System.out.println(weina.name);
        System.out.println(weina.age);
    }
}

构造器详解

代码示例：

package com.jun.oop.Demo02;

/**
 * 一个类即使什么都不写、它也会存在一个方法【构造方法=构造器】
 * 显示的定义构造器
 * 构造器特点：
 *         1. 必须和类的名字相同
 *         2. 必须没有返回类型、也不能写void
 * 构造器作用：
 *         1. 使用new关键字本质在调用构造器
 *         2.初始化对象的值
 *     注意：
 *         1. 一旦定义了有参构造、一旦想使用无参构造、其必须显示定义
 */
public class Person {
    String name;

    //无参构造【自带】
    public Person() {
        
    }
    //有参构造【重载】
    public Person(String name) {
        this.name = name;
    }
    //快捷键生成构造器：Alt + insert
}
*****************************************************************************************
package com.jun.oop.Demo02;
//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //使用new 关键词实例化一个对象
        Person person = new Person("林俊杰");
        System.out.println(person.name);  //林俊杰
    }
}

创建对象内存分析

package com.jun.oop.Demo03;
public class Pet {
    public String name;
    public int age;
    public void shout() {
        System.out.println("叫一声！");
    }
}
*****************************************************************************************
 package com.jun.oop.Demo03;
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        //调用无参构造
        dog.name="旺财";
        dog.age = 20;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();
        cat.age = 5;
        cat.name = "小黑";
        cat.shout();
        System.out.println(cat.name);
        System.out.println(cat.age);
    }
}
// 学会分析内存！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6GfYs9G2-1644311170527)(C:\Users\宋春杰\Desktop\JavaSE资料\图例\内存分析.png)]

javase26：面向对象03

封装

程序设计要追求"高内聚、低耦合"。

高内聚:类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅暴漏少量的方法给外部使用

封装【数据的隐藏】

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

*私有属性 : get / set

package com.jun.oop;
//类   private: 私有
public class Student {
    //属性私有
    private String name; //名字
    private int id; //学号
    private char sex; //性别
    private int age;

    public void setId(int id) {
        this.id = id;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.age = 3;
        } else {
            this.age = age;
        }
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }

    /**
     * 提供一些可以操作这些属性的方法
     * 提供一些public的get、set方法
     */

    //get 获得这个数据
    public String getName() {
        return this.name;
    }

    //set 给这个数据设置值【有时set会做一些安全性的判断】
    public void setName(String name) {
        this.name = name;
    }
    //快捷键：alt+insert
}
*****************************************************************************************
package com.jun.oop;
/**
 * 封装的意义：
 *
 *  1.提高程序的安全性、更好的保护数据
 *  2.隐藏代码的实现细节
 *  3.统一接口
 *  4.增加系统可维护性
 */
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("宋春峻");
        System.out.println(student.getName());
        student.setAge(-1);
        System.out.println(student.getAge());
    }
}

继承

继承的本质是对某一批类的抽象、从而实现对现实世界更好的建模

*extands意思是 “扩展”。子类是父类的扩展

JAVA中类只有单继承、无多继承！

继承是类和类之间的一种关系、除此之外——>【依赖、组合、聚合】

继承关系的两个类、一个是子类（派生类）、一个是父类（基类）。子类继承父类、使用关键字extends来表示

子类和父类之间，从意义上讲应该具有"is a"的关系

package com.jun.oop.Demo04;
public class Person /* extends Object */ {
    // 四个修饰符
    // 在java中所有的类、都默认或直接继承Object类
    private int money = 10_0000_0000;

    public void say(){
        System.out.println("说话！");
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}
*****************************************************************************************
    package com.jun.oop.Demo04;
// Student is Person

/**
 * 子类继承父类、就会拥有父类的所有方法
 */
public class Student extends Person {
    
}
*****************************************************************************************
    package com.jun.oop.Demo04;
// Teacher is Person
public class Teacher extends Person{
    // 快捷键：Ctrl+h  继承目录
}

super

package com.jun.oop.Demo04;
public class Person {
    protected String name = "chunjun";
    //prviate：私有的无法被继承
    public void print() {
        System.out.println("Person");
    }
    public Person() {
        System.out.println("Person无参构造被执行！");
    }
}
*****************************************************************************************
    package com.jun.oop.Demo04;

public class Student extends Person {
    private String name = "贺包子";

    public void test(String name) {
        System.out.println(name); //宋凌宇
        System.out.println(this.name); //贺包子
        System.out.println(super.name); //chunjun
    }

    public Student() {
        //隐藏代码：结果说明调用了父类的无参构造
        super();//调用父类的构造器、必须要在子类构造器的第一行
        System.out.println("Student构造被执行！");
    }
    @Override
    public void print() {
        System.out.println("Student");
    }
    public void test1() {
        print(); // Student
        this.print(); // Student
        super.print(); // Person
    }
}
*****************************************************************************************
    package com.jun.oop;


import com.jun.oop.Demo04.Student;

public class Application {
    public static void main(String[] args) {

        Student student = new Student();//Person无参构造被执行！ Student构造被执行！
        // student.test("宋凌宇");
        // student.test1();

        /**
         * super注意点：
         *           super调用父类的构造方法，必须在构造方法的第一个！
         *           super必须只能出现在子类的方法或者构造方法中！
         *           super 和 this不能同时调用构造方法！
         * 与 this相比：
         *           1.代表的对象不同：
         *           this:本身调用者这个对象
         *           super：代表父类对象的引用
         *           2.前提：
         *           this:没有继承也可以使用
         *           super：只能在继承条件下才可以使用
         *           3.构造方法：
         *           this(): 本类的构造
         *           super(): 父类的构造
         */
    }
}

方法重写

package com.jun.oop;
import com.jun.oop.Demo05.A;
import com.jun.oop.Demo05.B;
//静态方法和非静态方法差别很大
//方法的调用只和左边定义的数据类型有关
//非静态：重写
public class Application {
    public static void main(String[] args) {

        A a = new A();
        a.test(); //A=>test()
        //父类的应用指向了子类
        B b = new A(); //子类重写了父类的方法
        b.test(); //A=>test()
    }
    /**
     * 重写：
     *     需要有继承关系、子类重写父类的方法
     *     1.方法名必须相同
     *     2.参数列表必须相同
     *     3.修饰符：范围可以扩大、不能缩小 【public>Protected>Default>private】
     *     4.抛出的异常：只能缩小、不能扩大 ClassNotFoundException --> Exception(大)
     *
     *     重写、子类的方法必须和父类一致、方法体不同！
     *     为什么需要重写？
     *     父类的功能、子类不一定需要 或者不一定满足！
     *     Alt + Insert : override
     */
}
*****************************************************************************************
package com.jun.oop.Demo05;
//重写都是方法的重写、与属性无关
public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}
*****************************************************************************************
package com.jun.oop.Demo05;
public class A extends B {
    @Override //注解：有功能的注解
    public void test() {
        System.out.println("A=>test()");
    }
}

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的、但可以指向对象的引用的类型有很多（父类、有关系的类）

多态存在的条件：

有继承关系
子类重写父类方法
父类引用指向子类对象

注意：多态是方法的多态、属性没有多态性

package com.jun.oop;
import com.jun.oop.Demo06.Person;
import com.jun.oop.Demo06.Student;
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
        //可以指向的引用类型就不确定： 父类的引用指向了子类
        //Student 能调用的方法都是自己的或者继承父类的！
        Student a = new Student();
        //Person 父类型、可以指向子类、但是不能调用子类独有的方法
        Person b = new Student();
        Object c = new Student();
        //对象能执行哪些方法、主要是看对象左边的类型、和右边关系不大！
        b.run(); //run
        a.run(); //run
        ((Student) b).eat(); // eat方法被执行!  子类重写了父类的方法、执行子类的方法

    }
}
*****************************************************************************************
package com.jun.oop.Demo06;
public class Student extends Person {
    @Override
    public void run() {
        System.out.println("run");
    }
    public void eat(){
        System.out.println("eat方法被执行!");
    }
}
*****************************************************************************************
package com.jun.oop.Demo06;
public class Person {
    public void run(){
        System.out.println("run方法被执行！");
    }
    /**
     * 多态的注意事项：
     *             1. 多态是方法的多态、属性没有多态
     *             2. 父类和子类：有联系 类型转换异常！ ClassCastException!
     *             3. 存在条件： 继承关系、方法需要重写
     *             4. 父类的引用指向子类对象！ Father f1 = new Son();
     *
     *             不能重写：
     *             1. static方法 属于类不属于实例
     *             2.final
     *             3.private 方法
     *
     *
     */
}

instanceof （类型转换）引用类型

package com.jun.oop;
import com.jun.oop.Demo06.Person;
import com.jun.oop.Demo06.Student;
import com.jun.oop.Demo06.Teacher;

/**
 * [ x instanceof y ] 能不能编译通过！！  1.要有父子继承关系  2.x指向的类型和y有关系
 */
public class Application {
    public static void main(String[] args) {
        //Object > String
        //Object > Person > Student
        //Object > Person > Teacher
        Object object = new Student();

        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person);  //true
        System.out.println(object instanceof Teacher); //false
        System.out.println(object instanceof Object);  //true
        System.out.println(object instanceof String);  //false

        Person person = new Student();
        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person);  //true
        System.out.println(person instanceof Teacher); //false
        System.out.println(person instanceof Object);  //true
        //编译报错：System.out.println(person instanceof String);

        Student student = new Student();
        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person);  //true
        //编译报错：System.out.println(student instanceof Teacher);
        System.out.println(student instanceof Object);  //true
        //编译报错：System.out.println(student instanceof String);
    }
}
*****************************************************************************************
package com.jun.oop;
import com.jun.oop.Demo06.Person;
import com.jun.oop.Demo06.Student;


/**
 * [ x instanceof y ] 能不能编译通过！！  1.要有父子继承关系  2.x指向的类型和y有关系
 */
public class Application {
    public static void main(String[] args) {
        // 类型之间的转换： 父  子
        //由高到低：父转子 student将这个对象转换为Student类型、才可以使用Student的方法
        Person jun = new Student();
        ((Student) jun).go();

        //由低到高：子转父 可能会丢失自己本来的一些方法
        Student student = new Student();
        student.go();
        Person person = student;
        //报错： person.go();

        /**
         * 1. 父类引用指向子类对象
         * 2. 把子类转换为父类、向上转型！
         * 3. 把父类转换为子类、向下转型 【强制转换】
         * 4. 方便方法的调用、减少重复的代码！ 简介
         *
         * 抽象：封装  继承  多态！  【抽象类、接口】
         */

    }
}
*****************************************************************************************package com.jun.oop.Demo06;
public class Teacher extends Person {
}
*****************************************************************************************
package com.jun.oop.Demo06;
public class Student extends Person {
public void go(){
    System.out.println("执行go方法！！");
}
}
*****************************************************************************************
package com.jun.oop.Demo06;
public class Person {
    public void run(){
        System.out.println("run方法被执行！");
    }
}
*****************************************************************************************

javase27：面向对象04

static关键字

静态方法、静态属性

package com.jun.oop.Demo07;
//static
public class Student {
    private static int age;  //静态的变量  多线程！
    private double score;    //非静态的变量

    public void run() {

    }

    public static void go() {  //静态方法

    }

    public static void main(String[] args) {
        //Student s1 = new Student();
        //System.out.println(Student.age);
        //System.out.println(s1.score);
        new Student().run();
        Student.go();
        go();
        /**
         * 非静态方法可以调用静态方法、静态方法不可以调用非静态方法
         *    静态方法随着类的加载而加载！！
         */
    }
}

静态代码块

    {
        // 代码块 【匿名代码块】：在创建Person对象时自动创建、在调用构造器之前
    }

    static{
        // 静态代码块：在类加载时执行 永久执行一次
    }
*****************************************************************************************
package com.jun.oop.Demo07;
public class Person {
    {
        System.out.println("匿名代码块"); // 2
    }

    static {
        System.out.println("静态代码块"); // 1
    }

    public Person() {
        System.out.println("构造方法"); // 3
    }

    public static void main(String[] args) {
        Person person01 = new Person(); // 2 1 3
        System.out.println("========================");
        Person person02 = new Person(); // 2 3
    }
}
*****************************************************************************************
package com.jun.oop.Demo07;
//静态导入包 ~
import static java.lang.Math.random;
public class Person {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

final

/**
* 1.简单区别：
* final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。
* finally是异常处理语句结构的一部分，表示总是执行。
* finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收
* 例如关闭文件等。
*/
/**
 * 2.中等区别：
 *     虽然这个单词在Java中都存在，但是并没太多关联：
 *  final：java中的关键字，修饰符。
 *    A).如果一个类被声明为final，就意味着它不能再派生出新的子类，不能作为父类被继承。
 *    因此，一个类不能同时被声明为abstract抽象类的和final的类。
 *    
 *    B).如果将变量或者方法声明为final，可以保证它们在使用中不被改变.
 * 　　1)被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。
 * 　　2)被声明final的方法只能使用，不能重载。
 * 
 *  finally：java的一种异常处理机制。
 * 　　finally是对Java异常处理模型的最佳补充。finally结构使代码总会执行，而不管无异常发生。
 *    使用finally可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，
 *    如果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。
 *    
 *  finalize：Java中的一个方法名。
 *     Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。
 *     这个方法是由垃圾收集器在确定这个对象没被引用时对这个对象调用的。它是在Object类中定义的，因此所的类都继承了它。
 *     子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。
 *
 */

抽象类

【abstract】可以用来修饰方法也可以修饰类，如果修饰方法，该方法是抽象方法，如果修饰类该类为抽象类

抽象类中可以没有抽象方法、但是有抽象方法的类一定要声明为抽象类

抽象类不能使用new关键字来创建对象、它是让子类继承的

抽象方法、只有方法的声明、没有方法的实现、它是用来让子类实现的

子类继承抽象类，就必须要实现抽象类中没有实现的抽象方法、否则该子类也必须声明为抽象类

package com.jun.oop.Demo08;
// abstract抽象类  类：逃不开继承【extends】 弊端：只能单继承不能多继承 【接口可以】
public abstract class Action {

    /**
     * 抽象方法 ：只有方法名字、无方法实现
     *           ~有人帮实现
     * 抽象类特点：
     *          1. 不能new这个抽象类、只能让子类实现它：约束！
     *          2. 抽象类中可以写普通方法、抽象方法必须在抽象类中
     *
     */
    public abstract void something();
    
}
*****************************************************************************************
package com.jun.oop.Demo08;
public class A extends Action {
    /**
     * 抽象类的所有方法、继承了它的子类、都必须要实现它的方法
     * 除非本身也是抽象类【让别的类实现】
     */
    @Override
    public void something() {

    }
}
*****************************************************************************************
    思考：1.抽象类存在构造器么【不能new对象】？？
         2.抽象类存在的意义？？

思考1

/**
* 存在构造器
* 即使你没有提供任何构造函数，编译器将为抽象类添加默认的无参数的构造函数，没有的话你的子类将无法编译，因为在任
* 何构造函数中的第一条语句隐式调用super（）
*/

思考2

//java中抽象类更利于代码的维护和重用

接口

普通类：只有具体实现！
抽象类：具体实现和规范（抽象方法）都有！
    
// 接口：只有规范！自己无法写方法：专业的约束  约束和实现分离：面向接口编程
接口就是规范，定义的是一组规则，体现了现实世界中 "如果你是...则必须能..."的思想。
//如果你是车、则必须能跑；如果你是歌手、则必须能唱...

接口的本质是契约、就像我们人间的法律一样、制定好后大家都遵守！
// OO的精髓、是对对象的抽象、最能体现这一点的就是接口。为什么我们讨论设计模式、因为设计模式所研究的
// 实际上就是如何合理的去抽象【设计模式只针对具备抽象能力的语言C++、Java】

声明类的关键字是CLASS、声明接口的关键字是interface

package com.jun.oop.Demo09;
public interface TimeSerivce {
    void Timer();

    /**
     * （1）接口中只能放静态常量、抽象方法。
     *
     * （2）java接口是对功能的扩展（父类和抽象类中一般都存放的是通用的属性和方法，我们一般把扩展的功能或特有的功能放到接口里，而不放在父类或抽象类中）。
     *
     * （3）通过实现接口，java类可以实现多实现（一个类可以实现多个接口，即一个类可以有多种功能）。
     *
     * （4）一个类只能继承一个父类，即extends关键字后面只能跟一个父类，但可以通过implements关键字实现，多个接口。
     *
     * （5）接口与接口之间可以通过extends关键字来产生继承关系（即接口继承接口使用关键字extends）。 
     *
     */
}
*****************************************************************************************
package com.jun.oop.Demo09;
// interface 定义的关键字，接口都需要有实现类
public interface UserService {

    // 接口中所有的定义其实都是抽象的 public abstract
    void add(String name);
    void dlelete(String name);
    void update(String name);
    void query(String name);

    // 常量~ public static final
    int age = 15;
}
*****************************************************************************************
package com.jun.oop.Demo09;
/**
 * 抽象类： extends
 * 类 可以实现接口  implements  接口
 * 实现了接口的类必须重写接口中的方法 [利用接口实现多继承]
 */
public class UserServiceImpl implements UserService,TimeSerivce {
    @Override
    public void add(String name) {
    }

    @Override
    public void dlelete(String name) {
    }

    @Override
    public void update(String name) {
    }

    @Override
    public void query(String name) {
    }

    @Override
    public void Timer() {
    }
}

内部类

内部类就是在一个类的内部定义一个类,比如在A类中定义一个B类,那么B类相对于A类就是一个内部类,A类相对于B类是一个外部类

成员内部类

package com.jun.oop.Demo10;
public class Outer {
    private int id = 10;

    public void out() {
        System.out.println("这是外部类的方法!");
    }

    public class Innter {
        public void in() {
            System.out.println("这是内部类的方法!");
        }
        // 获得外部类的私有属性,方法
        public void getId(){
            System.out.println(id);
        }
    }
}

静态内部类

// 在成员内部类的基础上 + static

局部内部类

package com.jun.oop.Demo10;

public class Outer {
    //局部内部类
    public void method(){
        class B{

        }
    }
}

//一个java类中可以有多个class类,但是只有一个 public class
class A {
    public static void main(String[] args) {

    }
}

匿名内部类

package com.jun.oop.Demo10;
public class Test {
    public static void main(String[] args) {
        // 没有名字初始化类,不用将实例保存到变量中
        new apple().eat();
        
        UserService userService = new UserService() {
            @Override
            public int insert() {
                return 0;
            }
        };

    }
}

class apple {
    public void eat() {
        System.out.println("1");
    }
}

interface UserService{
    int insert();
}

javase28：异常

什么是异常

软件程序在运行过程中,可能会遇到许多异常,英文是Exception,意思是例外.这些例外情况或者叫异常,怎么让我们写的程序做出合理的处理,而不至于程序崩溃.

异常指程序运行中出现的不期而至的各种状况,如文件找不到,网络连接失败,非法参数等

异常发生在程序运行期间,它影响了正常的程序执行流程

简单分类

要理解Java异常处理是如何工作的，你需要掌握以下种类型的异常:

◆ 检查性异常: 最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了，这些异常在编译时不能被简单地忽略。

◆ 运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

◆ 错误ERROR: 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

异常处理框架

Java把异常当作对象来处理,并定义一个基类java.langThrowable作为所有异常的超类

在Java API中已经定义了许多异常类,这些异常类分为两大类,错误Error和Exception

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GNixnwLq-1644311170529)(C:\Users\宋春杰\Desktop\JavaSE资料\图例\异常类层次结构图.png)]

VirtulMachineError: 虚拟机异常

AWTError: GUI编程图形化界面编程

Error

◆ Error类对象由Java虚拟机生成井抛出，大多数错误与代码编写者所执行的操作无关。

◆ Java虚拟机运行错误(Virtual MachineError)，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError.这些异常发生时，Java虚拟机 (JVM)一般会选择线程终止;

◆ 还有发生在虚拟机试图执行应用时，如类定义错误(NoClassDefFoundError)、链接错误 (LinkageError) .这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

Exception

◆在Exception分支中有一个重要的子类RuntimeException (运行时异常)

◆ArrayIndexOutOfBoundsException (数组下标越界)

NullPointerException (空指针异常)

◆ArithmeticException (算术异常)

MissingResourceException (丢失资源)

◆ClassNotFoundException (找不到类)等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

◆这些异常-般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生;

**◆Error和Exception的区别: **

1.Error通常是灾难性的致命的错误，是程序无法控制和处理的，当

出现这些异常时，Java虚拟机(JVM) - 般会选择终止线程

2. Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

javase29：异常处理机制

抛出异常

package com.jun.oop.Demo11;
import java.security.PublicKey;

public class Test2 {
    public static void main(String[] args) {
        // 抛出后捕获异常！ 捕获异常后，程序依旧执行
        try {
            new Test2().Test(1, 0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }

    //假设这个方法中处理不了这个异常，可在方法上抛出！
    public void Test(int a, int b) throws ArithmeticException{
        if (b == 0) { // throw throws
            throw new ArithmeticException(); // 主动的抛出异常! 【一般在方法中使用！】
        }
        System.out.println(a / b);
    }
}

捕获异常

package com.jun.oop.Demo11;
public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //假设要捕获多个异常 ：从小到大 【否则报错】
        try { // try:监控区域
            System.out.println(a / b);
        } catch (Error e) { // catch(想要捕获的异常类型!):捕获异常
            System.out.println("Error!");
        } catch (Exception e) {
            System.out.println("Exception!");
        } catch (Throwable t) {
            System.out.println("Throwable!");
        } finally {
            System.out.println("finally:一定被执行的语句"); // 处理善后工作 !
        }
        // 异常处理时可以不要finally 当出现IO流 资源 关闭时可用finally处理!
    }
}

//捕获异常快捷键:选中一行 Ctrl + Alt + T

package com.jun.oop.Demo11;
public class Test2 {
    public static void main(String[] args) {
        int b = 0;
        int a = 1;
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();  // 打印错误的栈信息
        } finally {

        }
    }
}

异常处理五个关键字 : [try] [catch] [finally] [throws]

自定义异常

◆使用Java内的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。

◆在程序中使用自定义异常类，大体可分为以下几个步骤:

创建自定义异常类。
在方法中通过throw关键字抛出异常对象。
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理; 否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

在出现异常方法的调用者中捕获并处理异常。

package com.jun.oop.Demo12;
// 继承Exception类，自定义异常类！
public class MyException extends Exception {
    //传递数字大于10
    private int detail;

    public MyException(int a) {
        this.detail = a;

    }

    //toString 异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}
**************************************************************************************
package com.jun.oop.Demo12;
public class Test {
    static void test(int a) throws MyException {
        System.out.println("传递的参数为：" + a);
        if (a > 10) {
            throw new MyException(a);
        }
        System.out.println("ok!");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("MyException==>"+e);
        }
    }
}

    /**
     *  
     *  实际应用中的经验总结：
     *  
     *  处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
     *  在多重catch块后面，可以加一个catch【Exception】 来处理可能被遗漏的异常
     *  对于不确定的代码，也可以加上try-catch，处理潜在的异常
     *  尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
     *  具体如何处理异常，根据不同的业务需求和异常类型去决定
     *  尽量添加finally语句去释放占用的资源
     */

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cb5EUP2s-1644311170530)(C:\Users\宋春杰\Desktop\JavaSE资料\图例\javase常用API.jpeg)]

择线程终止;**

Exception

◆在Exception分支中有一个重要的子类RuntimeException (运行时异常)

◆ArrayIndexOutOfBoundsException (数组下标越界)

NullPointerException (空指针异常)

◆ArithmeticException (算术异常)

MissingResourceException (丢失资源)

◆ClassNotFoundException (找不到类)等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

◆这些异常-般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生;

**◆Error和Exception的区别: **

1.Error通常是灾难性的致命的错误，是程序无法控制和处理的，当

出现这些异常时，Java虚拟机(JVM) - 般会选择终止线程

2. Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

javase29：异常处理机制

抛出异常

package com.jun.oop.Demo11;
import java.security.PublicKey;

public class Test2 {
    public static void main(String[] args) {
        // 抛出后捕获异常！ 捕获异常后，程序依旧执行
        try {
            new Test2().Test(1, 0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }

    //假设这个方法中处理不了这个异常，可在方法上抛出！
    public void Test(int a, int b) throws ArithmeticException{
        if (b == 0) { // throw throws
            throw new ArithmeticException(); // 主动的抛出异常! 【一般在方法中使用！】
        }
        System.out.println(a / b);
    }
}

捕获异常

package com.jun.oop.Demo11;
public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //假设要捕获多个异常 ：从小到大 【否则报错】
        try { // try:监控区域
            System.out.println(a / b);
        } catch (Error e) { // catch(想要捕获的异常类型!):捕获异常
            System.out.println("Error!");
        } catch (Exception e) {
            System.out.println("Exception!");
        } catch (Throwable t) {
            System.out.println("Throwable!");
        } finally {
            System.out.println("finally:一定被执行的语句"); // 处理善后工作 !
        }
        // 异常处理时可以不要finally 当出现IO流 资源 关闭时可用finally处理!
    }
}

//捕获异常快捷键:选中一行 Ctrl + Alt + T

package com.jun.oop.Demo11;
public class Test2 {
    public static void main(String[] args) {
        int b = 0;
        int a = 1;
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();  // 打印错误的栈信息
        } finally {

        }
    }
}

异常处理五个关键字 : [try] [catch] [finally] [throws]

自定义异常

◆使用Java内的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。

◆在程序中使用自定义异常类，大体可分为以下几个步骤:

创建自定义异常类。
在方法中通过throw关键字抛出异常对象。
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理; 否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

在出现异常方法的调用者中捕获并处理异常。

package com.jun.oop.Demo12;
// 继承Exception类，自定义异常类！
public class MyException extends Exception {
    //传递数字大于10
    private int detail;

    public MyException(int a) {
        this.detail = a;

    }

    //toString 异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}
**************************************************************************************
package com.jun.oop.Demo12;
public class Test {
    static void test(int a) throws MyException {
        System.out.println("传递的参数为：" + a);
        if (a > 10) {
            throw new MyException(a);
        }
        System.out.println("ok!");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("MyException==>"+e);
        }
    }
}

    /**
     *  
     *  实际应用中的经验总结：
     *  
     *  处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
     *  在多重catch块后面，可以加一个catch【Exception】 来处理可能被遗漏的异常
     *  对于不确定的代码，也可以加上try-catch，处理潜在的异常
     *  尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
     *  具体如何处理异常，根据不同的业务需求和异常类型去决定
     *  尽量添加finally语句去释放占用的资源
     */

JAVASE

javase 01：注解

注解的种类：

说明：文档注释可以加参数，与JavaDoc联合使用（大公司会使用），优秀的开发者代码编写一定规范。

javase02：标识符和关键字

关键字：

标识符：

javase03 : 数据类型

强类型语言：

java的数据类型分为两大类：

基本类型（Primitive type）： 数值类型、boolean类型（八大基本数据类型）

引用类型：Reference Type

javase04: 数据类型扩展

javase05：类型转换

javase06:变量、常量、作用域

变量： 可以变化的量！

变量作用域

常量

变量的命名规范

驼峰规则

javase07:基本运算符

java语言支持的运算符

代码示例

javase08：自增自减运算符、初识Math类

自增、自减

代码示例

javase09：逻辑运算符、位运算符

逻辑运算符代码示例

位运算符代码示例

javase10:三元运算符及小结

优先级：

javase11:包机制

包机制的理解

参考书籍：阿里巴巴开发手册【全网】

javase12：javaDoc生成文档

命令行生成javaDoc文档

IDEA生成javaDoc文档

javase13：流程控制【一】

用户交互Scanner

基本语法

next（）与 nextLine（）区别

Scanner进阶使用

代码练习

javase14：流程控制【二】

顺序结构

选择结构

看源码

javase15：流程控制【三】

while 循环

do…while循环

for循环**

Java5中引入了一种主要应用于数组、集合对象的增强型For循环

break、continue、goto

javase16：流程控制练习题

javase17：方法01

System.out.println() 的理解

java方法是语句的集合，他们在一起执行一个功能

方法设计的原则

回顾

方法的命名规则：首字母小写后面是驼峰命名

代码示例

javase18：方法02

方法的定义

代码示例

方法的调用

javase19：方法03

方法重载

命令行传参

可变参数

递归【面试高频】

理解递归

练习

javase20：数组01

数组定义

数组声明创建

javase21：数组02

内存分析

数组三种初始化

下标越界及小结

javase22：数组03

基本类型（Primitive type）：数值类型、boolean类型（八大基本数据类型）

变量：可以变化的量！

instanceof （类型转换）引用类型