Java 代码cd到某个目录下 java实现cd目录切换功能

阿玉子学习课程的地址：https://www.bilibili.com/video/BV12J41137hu?p=80

1. 基本dos命令

# 盘符切换 （例：D:）
# 查看当前目录下的所有文件 dir
# 切换目录 cd （change directory）
    （例：cd /d f:（通过/d进行跨盘符的切换））
         cd /d E:Text1
  1.回到上一级 cd..
  2.进入下一级 cd 文件名
# 清理屏幕 cls (clear screan)             
# 退出终端 exit
# 查看电脑IP ipconfig
# 打开一些应用
  1.计算器     calc
  2.画图工具   mspaint          
  3.记事本  	notepad    
# ping命令
  （例如：ping www.baidu.com）
# 文件操作
  1.创建目录 	md
  2.移除目录 	rd
  3.创建文件 	cd>文件名
  4.删除文件 	del 文件名

2. 卸载JDK

1. 找出环境变量，找到java的路径，删除java安装目录

2. 删除JAVA_HOME

3. 删除path下关于Java的目录

4. 在cmd中查看：java -version

3. 安装JDK

1. 百度搜索JDK8,找到下载地址
2. 同意协议
3. 下载电脑对应的版本
4. 双击安装JDK
5. 记住安装路径
6. 配置环境变量
    6.1 我的电脑——>右键——>属性
    6.2 环境变量 在系统变量中新建JAVA_HOME（变量名），将JDK安装路径放入变量值中
    6.3 配置path变量
    	%JAVA_HOME%\bin
    	%JAVA_HOME%\jre\bin
7. 测试JDK是否安装成功
    打开cmd输入：java -version

4. HelloWorld

1. 新建一个文件夹存放代码
2. 新建一个java文件
   2.1 文件后缀名为.java
   2.2 Hello.java
   2.3 【注意】系统可能没有显示文件后缀名，需要手动打开
3. 编写代码

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

1. 编译javac java文件，会生成一个class文件
2. 运行class文件，java class文件

可能会遇到的情况

1. 每个单词的大小写不能出现问题，Java是大小写敏感的
2. 尽量使用英文
3. 文件名 和 类名 必须保证一致，并且首字母大写
4. 符号使用了中文

5. java运行机制

编译：只需编译一次就可以把源代码编译成机器语言（一次编译完成）

解释：先翻译成中间代码，再由解释器对中间代码进行解释运行（要执行什么就解释什么）

6. 数据类型扩展

//整数拓展： 进制		二进制0b		十进制		八进制0		十六进制0x
public class HelloWorld {
    public static void main(String[] args) {
int i=10;
int i1=010;
int i2=0x10;
System.out.println(i);
System.out.println(i1);
System.out.println(i2);
    }
}

//浮点数拓展： 银行业务怎么表示？ 钱？
//BigDecimal	数学工具类
//float 有限 离散 舍入误差 大约 接近但不等于
//最好完全避免使用浮点数进行比较
public class HelloWorld {
    public static void main(String[] args) {
        float f=0.1f;
        double d=1.0/10;
        float d1=1233121313213f;
        float d2=d1+1;
        System.out.println(f==d);
        System.out.println(d1==d2);
    }
}

//字符拓展
public class HelloWorld {
    public static void main(String[] args) {
       char a='a';
       char b='中';
        System.out.println(a);
        System.out.println((int)a);		//强制类型转换
        System.out.println(b);
        System.out.println((int)b);
        //所有的字符本质还是数字
        //编码 Unicode 表：（97=a 65=A）2字节 0-65536	Excel 2^16=65536
        // U0000 UFFFF
        char c='\u0061';
        System.out.println(c);	//a
        //转义字符
        //\t 制表符	\n换行 ...
    }
}

//布尔值拓展
boolean flag=true;
if(flag){
}

7.快捷键

1. 删除光标所在行代码

idea快捷键： Ctrl+X

eclipse快捷键： Ctrl+D

2. 复制光标所在行代码，或者鼠标选中的代码
idea快捷键： Ctrl+D
eclipse快捷键： Ctrl+Alt+上下键

3. 切换代码大小写
idea： Ctrl+Shift+U
eclipse： Ctrl+Shift+X（大写） Ctrl+Shift+Y（小写）

4. 关闭当前代码窗
idea： Ctrl+F4
eclipse： Ctrl+W

5. 快速定位到上一次编辑的位置
idea： Ctrl+Alt+左右键
eclipse：Ctrl+Q

6. 快速搜索类和接口
idea：Ctrl+Shift+R
eclipse：Ctrl+Shift+R

7. 切换上一次的浏览栏
idea：Alt+左右键
eclipse：Alt+左右键

8. 生成get，set方法
idea快捷键： Alt+insert
eclipse快捷键： Shift+Alt+S

9. 格式化代码
idea：先Ctrl+A选择全部代码 然后 Ctrl+Alt+L
eclipse：先Ctrl+A选择全部代码 然后 Ctrl+I格式化代码

10. 下上移动正行代码
idea：Shift+Ctrl+上下键
eclipse：Ctrl+Alt+上下键

11. 接口快速进入实现方法
idea：鼠标放在接口方法上，然后快捷键 Ctrl+Alt+B 进入实现方法
eclipse：鼠标放在接口方法上，然后快捷Ctrl+鼠标右键，显示出来实现方法，点击进入

8. 类型转换

public class HelloWorld {
    public static void main(String[] args) {
       int i=128;
       byte b=(byte)i;	//内存溢出
       double c=i;		//自动转换
        //强制转换 （类型）变量名  高--低
        //自动转换                低--低
        System.out.println(b);  
		System.out.println(c);
        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.在把高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者精度问题！！！！
        */
        //操作比较大的数的时候，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割
        int money=10_0000_0000;
        int years=20;
        int total=money*years;  //-1474836480，计算的时候溢出了
        long total1=money*years;    //默认是int，转换之前已经出问题了
        long total2=money*(long)years;	//先把一个数转换为long
        System.out.println(total);
        System.out.println(total1);
        System.out.println(total2);   
    }
}

9. 变量

public class HelloWorld {

    //类变量 static
    static double salary=2500;

    //属性：变量

    //实例变量：从属于对象；如果不自行初始化，则是这个类型的默认值 0，0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化
        int i=10;
        System.out.println(i);		//10

        //变量类型 变量名字=new HelloWorld
        HelloWorld demo08=new HelloWorld();
        System.out.println(demo08.age);		//0
        System.out.println(demo08.name);	//null

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

    }

    //其他方法
    public void add(){

    }
}

public class HelloWorld {
    //常量
    //修饰符，不存在先后顺序
    static final double pi=3.14;
    public static void main(String[] args) {
        System.out.println(pi);
    }
}

变量的命名规范

1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastname lastName
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则：Man，GoodMan
6. 方法名：首字母小写和驼峰原则：run()，runRun()

10. 基本运算符

public class HelloWorld {
    public static void main(String[] args) {
        long a=123221233L;
        int b=123;
        short c=10;
        byte d=8;
		//默认为int
        System.out.println(a+b+c+d);    //long
        System.out.println(b+c+d);      //int
        System.out.println(c+d);        //int
    }
}

public class HelloWorld {
    public static void main(String[] args) {
        //关系运算符返回的结果： 正确，错误   布尔值
        int a=10;
        int b=20;
        System.out.println(a>b);    //false
        System.out.println(a<b);    //true
        System.out.println(a==b);   //false
        System.out.println(a!=b);   //true
    }
}

public class HelloWorld {
    public static void main(String[] args) {
        //++ -- 自增，自减  一元运算符
        int x=3;
        int y=x++;      //执行完这行代码后，先给y赋值，再自增
        //x++ x=x+1
        System.out.println(y);
        System.out.println(x);
        int z=++x;      //执行完这行代码后，先自增，再给z赋值
        System.out.println(x);
        System.out.println(z);
        
        
        //幂运算 2^3 2*2*2=8	很多运算，我们会使用一些工具类来操作
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

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

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

    }
}

public class HelloWorld {
    public static void main(String[] args) {
        //位运算符
        /*
        A=0011 1100
        B=0000 1101

        A&B(与) = 0000 1100
        A|B(或) = 0011 1101
        A^B(异或) = 0011 0001
        ~B(非) = 1111 0010

        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);    //16
        
        
        //字符串链接符 +，String
        int a=10;
        int b=20;
        System.out.println(""+a+b);		//1020
        System.out.println(a+b+""); 	//30
        
        
        //三元运算符
        //x ? y : z
        //如果x==true，则结果为y，否则结果为z
        int score=80;
        String type=score<60 ? "不及格" : "及格";
        System.out.println(type);
    }
}

11. 包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名

包的语法格式为：

package pkg1[.pkg2[.pkg3]]; //package com.mei.xxx

一般利用公司域名倒置作为包名；

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

import package[.package2].(classname|*);

//* 导入这个包中所有的类

12. JavaDoc

javadoc命令是用来生成自己API文档的

参数信息：

1. @author 作者名
2. @version 版本号
3. @since 指明需要最早使用的jdk版本
4. @param 参数名
5. @return 返回值情况
6. @throws 异常抛出情况

package test;
//类注释
/**
 * @author zhangsan;
 * @version  1.0;
 * @since    1.8;
 */
public class Doc {
    //方法注释
    String name;
    /**
     * @author zhangsan;
     * @param name
     * @return
     * @throws Exception
     */

    public String test1(String name) throws Exception{
        return name;
    }
}

查看区别：

（通过命令行）

1、右键点击所在的类，点击Show in Explorer

2、导航栏进入cmd

3、输入命令行

javadoc：生成文档

-encoding UTF-8：编码为UTF-8

-charset UTF-8：让字符集编码也变为UTF-8

4、文件夹新生成了许多文件

5、点击首页index.html

点Doc，可以查看文档

（通过查找使用IDEA生产的 JavaDoc 文档） 百度！！！

13. Scanner对象

java.util.Scanner 我们可以通过Scanner类来获取用户的输入

基本语法：
Scanner s = new Scanner(System.in);  

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

package test.test;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner=new Scanner(System.in);

        System.out.println("使用next方法接收：");

        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next方式接收
            String str=scanner.next();
            System.out.println("输出的内容为："+str);

        }
		
        /*
        System.out.println("使用nextLine方法接收：");
        //判断用户有没有输入字符串
        if(scanner.hasNextLine()){
            //使用nextLine方式接收
            String str=scanner.nextLine();
            System.out.println("输出的内容为："+str);
        */
        
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关闭
        scanner.close();

    }
}

next()：

1. 一定要读取到有效字符后才可以结束输入
2. 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉
3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
4. next() 不能得到带有空格的字符串

nextLine()：

1. 以Enter为结束符，也就是说 nextLine() 方法返回的是输入回车之前的所有字符
2. 可以获得空白

Scanner进阶

package test.test;

import java.util.Scanner;

public class Demo01 {
    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 test.test;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输入出执行结果
        Scanner scanner=new Scanner(System.in);

        //和
        double sum=0;
        //计算输入了多少个数字
        int m=0;
        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            sum=sum+x;
            m++;
            System.out.println("你输入了第"+m+"个数据，当前的和为："+sum);
        }
        System.out.println(m+"个数的和为："+sum);
        System.out.println(m+"个数的平均数是"+(sum/m));

        scanner.close();

    }
}

14. 选择

if多选择结构

package test.test;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        
        /*
        if 语句至多有1个 else 语句，else 语句在所有的 else if 语句之后
        if 语句可以有若干个 else if 语句，它们必须在 else 语句之前
        一旦其中一个 else if 语句检测为true，其他的 else if 以及 else 语句都将跳过执行
         */

        System.out.println("请输入成绩：");
        int score=scanner.nextInt();

        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("成绩不合法！");
        }


        scanner.close();

    }
}

switch多选择结构

package test.test;

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

        char grade='C';

        switch (grade){
            case 'A':
                System.out.println("优秀");break;
            case 'B':
                System.out.println("良好");break;
            case  'C':
                System.out.println("及格");break;
            default:
                System.out.println("无等级");
        }
    }
}

15. 循环

while循环

package test.test;

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

do while循环

package test.test;

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

for循环

//快捷键：100.for 等价于
for (int i = 0; i < 100; i++) {
    
}

/*
        关于 for 循环有一下几点说明；

        最先执行初始化步骤，可以声明一种类型，但可以初始化一个或多个循环控制变量，也可以是空语句
        然后，检测布尔表达上的值，如果为true，循环体被执行，如果为false，循环中止，开始执行循环体后面的语句
        再次检测布尔表达式，循环执行上面的过程

*/
        
//死循环
for( ; ; ){
            
}

package test.test;

public class Demo01 {
    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("=================");

        //练习2：用 while 循环或 for 循环输出0~1000之间能被5整除的数，并且每行输出3个
        for (int i = 0; i < 1000; i++) {
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0){
                System.out.println();
            }
        }
        System.out.println();
        System.out.println("=================");

        //练习3：打印99乘法表
        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();
        }
    }
}

package test.test;

public class Demo01 {
    public static void main(String[] args) {
        int[] numbers={10,20,30,40,50};

        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("================");

        //遍历数组元素
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

16. break 和 continue

break：

package test.test;

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

    }
}

continue：

package test.test;

public class Demo01 {
    public static void main(String[] args) {
        int i=0;
        System.out.println(i);
        while(i<100){
            i++;
            if(i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i);
        }

    }
}

package test.test;

public class Demo01 {
    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+" ");
        }

    }
}

17. 打印三角形

package test.test;

public class Demo01 {
    public static void main(String[] args) {
        //打印三角形 5行

        for (int i = 0; i <= 5; i++) {
            for(int j=5;j>i;j--){
                System.out.print(" ");
            }
            for(int j=0;j<=i;j++){
                System.out.print("*");
            }
            for(int j=0;j<i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

    }
}

18. 方法

18.1 何谓方法

18.2 方法的定义

18.3 方法调用

package test.test;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(max(10,20));     //20

    }
    //比大小
    public static int max(int num1,int num2){
        int result=0;
        if(num1==num2){
            System.out.println("num1==num2");
            return 0;
        }
        if(num1>num2){
            result=num1;
        }else{
            result=num2;
        }
        return result;
    }

}

18.4 方法重载

18.5 命令行传参

文件夹中打开命令行

（运行时需要回退到src目录下）

18.6 可变参数

本质是数组！！！

package test;

public class Demo01 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(35,16,5,3,5,3,6);
        printMax(new double[]{2,1,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=1;i<numbers.length;i++){
            if(numbers[i]>result){
                result=numbers[i];
            }
        }
        System.out.println("The max value is "+result);
    }

}

18.7 递归

package test;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(f(4));       //24
    }

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

    }

}

19. 数组

19.1 数组的声明

19.2 内存分析

19.3 初始化

19.4 数组边界

19.5 数组使用

package test;

public class Demo01 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        //for...each遍历，JDK1.5版本以上，没有下标
        for (int array : arrays) {
            System.out.println(array);
        }
        System.out.println("===============");
        printArray(reverse(arrays));
    }

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

    //反转数组
    public static int[] reverse(int[] arrays){
        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;
    }

}

19.6 多维数组

20. Arrays类

21. 冒泡排序

package test;


import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        int[] a={26,3,25,6,39,4};
        System.out.println(Arrays.toString(sort(a)));

    }

    //冒泡排序
    //1. 比较数组中，两个相邻的元素，如果第一个比第二个数大，就交换他们的位置
    //2. 每一次比较，都会产生出一个最大，或者最小的数字
    //3. 下一轮则可以少一次排序！
    //4. 依次循环，直到结束！

    public static int[] sort(int[] array){
        //临时变量
        int temp;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length; 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;
                }


            }

        }
        return array;
    }


}

22. 稀疏数组

package test;

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        //1. 创建一个二维数组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();
        }

        System.out.println("==================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum=0;
        for (int[] ints : array1) {
            for (int i : ints) {
                if(i!=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("==================");
        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");
        }

        System.out.println("==================");
        System.out.println("还原");
        //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. 打印
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }


}

23. 面向对象

23.1 面向对象和面向过程

23.2 什么是面向对象

23.3 方法回顾

静态和非静态

方法1 调用 方法2

方法的参数类型

值传递

引用传递

23.4 对象与类

构造器：

1. 和类名相同
2. 没有返回值

作用：

1. new 本质在调用构造方法
2. 初始化对象的值

注意点：

1. 定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

23.5 创建对象内存分析

23.6 类和对象

1、类和对象

类是一个模板，抽象；对象是一个实例

2、方法

定义、调用

3、对象的引用

引用类型：基本类型（8）

对象是通过引用来操作的：栈 ----> 堆

4、 属性：字段Field 成员变量

默认初始化：

数字：0 0.0

char：u0000

boolean：false

引用：null

修饰符 属性类型 属性名=属性值

5、对象的创建和使用

必须使用 new 关键字创造对象，构造器 Person xiaohong = new Person();

对象的属性 xiaohong.name

对象的方法 xiaohong.eat

6、 类

静态的属性 属性

动态的行为 方法

23.7 面向对象三大特性

23.7.1封装

封装意义：
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加了

23.7.2继承

object类

super(属性)

super(方法)

super(构造器)

1、说明Student类无参构造中隐藏了代码，调用了父类的无参构造

super();

2、调用父类的构造器，必须要在子类构造器的第一行

super注意点：

1. super 调用的父类的构造方法，必须在构造方法的第一个
2. super 必须只能出现在子类的方法或者构造方法中
3. super 和 this 不能同时调用构造方法

vs this:

1. 代表的对象不同
   this： 本身调用者这个对象
   super：代表父类对象的引用
2. 前提：
   this： 没有继承也可以使用
   super：只能在继承条件下才能够使用
3. 构造方法：
   this()： 本类的构造
   super()：父类的构造

方法重写（注意对比区别，静态和非静态！）

**重写：**需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小 private -----> public
4. 抛出的异常：范围可以被缩小，但不能扩大
5. 总结：子类的方法和父类必须要一致，方法体不同！
6. 为什么需要重写？父类的功能，子类不一定需要，或者不一定满足！Alt + Insert：override

23.7.3 多态

子类重写了父类的方法

父类不能调用子类独有的方法

解决方法：通过强制转换调用子类的方法 ((Student)s2).eat()

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 （类型转换异常（猫不能转换成狗））
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son();
4. 不能别重写的方法：
   4.1 static 方法，属于类，不属于实例
   4.2 final 常量
   4.3 private 方法

23.8 instanceof 和 类型转换

instanceof

System.out.println(x instanceof y); //能不能编译通过？
取决于 x 和 y 之间存不存在父子关系，如果有父子关系则编译通过，如果没有则编译报错！

类型转换

父类引用指向子类对象

1. 把子类转换为父类，向上转型：自动转换
2. 把父类转换为子类，向下转型：强制转换（可能会丢失一些方法）
3. 为什么会强制转换？方便方法调用，减少重复的代码！简介

23.9 static 关键字详解

变量

方法

代码块

静态导入包

不导入包时，通过 Math.random() 产生随机数

23.10 抽象类

除非继承的子类也是抽象类

23.11 接口

接口UserService

接口TimeService

实现

接口作用：

1. 进行约束
2. 定义一些方法，让不同的人实现
3. 方法都是 public abstract
4. 常量都是 public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements 可以实现多个接口
7. 必须要重写接口中的方法

23.12 内部类

//一个java类中可以有多个class类，但是只能有一个public class

成员内部类

静态内部类

如果 Inner() 方法加上 static 关键字变为静态内部类，则 id 就拿不到了。

因为先实例化了静态的 Inner() ，此时id还没被实例化

局部内部类

方法中的类

匿名内部类

实例化的对象没有名字

24. 异常

什么是异常？

简单分类

Error

Exception

24.1 异常处理

24.1.1 try … catch

1. try…catch 必须有，finally 可以不要，假设IO流和一些资源需要关闭，一般都放在 finally 中
2. catch(异常类型) 中的参数是想要捕获的异常类型，最高的是throwable

可以捕获多个异常，但是必须按异常的从小到大写

先写大的再写小的报错了！

快捷键：选择想要包裹的语句后，Ctrl + Alt +T

System.exit(1) 手动结束程序

24.1.2 throw

24.1.3 throws

24.2 自定义异常