小小java基础知识小结(全)_doublepow怎么打开-CSDN博客

本文链接：https://blog.csdn.net/awmlgs/article/details/143827090

1 dos命令

java基础知识源代码git仓库：https://gitee.com/liang-guangsheng/learning-java-fundamentals
学习视频：https://search.bilibili.com/all?keyword=%E7%8B%82%E7%A5%9E%E8%AF%B4java&from_source=webtop_search&spm_id_from=333.1007&search_source=2

1.1打开CMD的方式

开始+系统+命令提示符
Win键 + R 输入cmd打开控制台
在任意的文件夹下面，按住shift键+鼠标右键点击，在此处打开命令行窗口
资源管理器的地址栏前面加上cmd路径

管理员方式运行，选择以管理员方式运行

1.2 常用的dos命令

#盘符切换
#查看当前目录下的所有文件 dir
#切换目录 cd change directory
cd ..
#清理屏幕 cls (clear screen)
#退出终端 exit
#查看电脑的ip ipconfig

#打开应用
   calc
   mspaint
   notepad
   
#ping 命令
  ping www.baidu.com
  
#文件操作
   md  目录名
   rd  目录名
   cd> 文件名
   del 文件名

1.3 Java三大版本

JavaSE: 标准版 (桌面程序，控制台开发…)
JavaME: 嵌入式开发 (手机，小家电…)，已经凉了
JavaEE: E企业级开发 (Web端，服务端开发…)，JavaSE为基础

JDK JRE JVM

JDK：Java Development Kit (Java开发者工具，包括 JRE，JVM)
JRE：Java Runtime Environment (Java运行时环境)
JVM：Java Virtual Machine (Java虚拟机，跨平台核心)

1.4 安装开发环境

卸载JDk

删除Java安装目录
删除环境变量JAVA_HOME
删除path下关于JAVA的目录
Java -version

安装JDK

百度搜索JDK8，找到下载地址
同意协议，下载电脑对应的版本，如64位操作系统下载 jdk-8u281-windows-x64.exe
双击安装JDK
记住安装路径
配置环境变量
我的电脑-》属性-》系统高级设置-》环境变量
系统变量新建–> JAVA_HOME 输入对应的jdk安装路径
path变量–>% JAVA_HOME%\bin
测试是否成功 cmd–>Java -version

2024最新版IntelliJ IDEA安装教程（非常详细）从零基础入门到精通，看完这一篇就够了_idea2024-CSDN博客

2 java基础

标识符和关键字

JAVA入门----标识符和关键字_java的$$-CSDN博客

2.1 数据类型拓展

//数据类型拓展
public class demo02 {
    public static void main(String[] args) {
        //整数拓展  二进制0b   八进制0   十进制   十六进制0x

        int i=10;
        int i1 =010;//八进制
        int i2 =0x11;//十六进制  0-9 A-f

        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println("==================");

        //浮点数拓展
        //float double  有限  离散  大约  接近但不等于
        //BigDecimal 数学工具类
        //最好完全避免使用浮点数进行比较
        float f = 0.1f;
        double d=1.0/10;
        System.out.println(f==d);//false


        float d1=211313131f;
        float d2=d1+1;
        System.out.println(d1 == d2);//true
        System.out.println("===========");

        //字符拓展
        char c1='a';
        char c2='中';

        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
        //所有字符本质还是数字
        //编码  Unicode 2字节  0-pow(2,16)  65536
        //u000  UFFFF
        char c3='\u0061';
        System.out.println(c3);

        //转义字符
        //\t \n
        System.out.println("hello\tWorld");

        System.out.println("==========");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa==sb);
        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);
        //对象  内存

        //布尔值拓展
        boolean flag = true;
        System.out.println("==========");
        if(flag){
            System.out.println("nice");
        }

    }
}

2.2 类型转换

//类型转换
public class demo03 {
    public static void main(String[] args) {
        //低-------------高
        // byte--short--char--int--long--float--double
        int i=128;
        byte b =  (byte)i;//内存溢出
        //强制转换  高-->低
        //自动转换  低-->高
        System.out.println(i);
        System.out.println(b);

        /* 注意点
        1，不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.高--》低 强制转换
        4，转换的时候可能存在内存溢出
        * */
        System.out.println("========");
        System.out.println((int)23.7);
        System.out.println((int)45.89f);


        System.out.println("========");
        char c='a';
        int d=c+1;
        System.out.println(d);
        System.out.println((char)d);
        System.out.println("***********");
        //操作比较大的时候，注意溢出的问题
        int money = 10_0000_0000;
        int year=20;
        int total = money*year;//溢出

        long total2=money*((long)year);
        
        System.out.println(total2);

        System.out.println("***********");
        
    }
}

2.3 变量常量作用域

变量

//变量
public class demo04 {
    //类变量  static
    static double salary=2500;

    //属性：变量

    //实例变量:从属于对象  如果不初始化，这个类型默认值
    //布尔值默认是false
    String name;
    int age=1;

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

        //变量类型  变量名字 = new demo04();
       demo04 demo04 = new demo04();
        System.out.println(demo04.age);
        System.out.println(demo04.name);
        System.out.println("---------");

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

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

    }
}

常量

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

    }
}

2.4 基本运算符

基本运算符

//基本运算符
package operator;
public class Demo01 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int c=25;
        int d=25;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);
    }
}

package operator;
//基本运算符
public class Demo02 {
    public static void main(String[] args) {
    long a=101010958L;
    int b=123;
    short c=10;
    byte d=8;

        System.out.println(a+b+c+d);//long
        System.out.println(b+c+d);//Int
        System.out.println((double)c+d);//double
    }
}

package operator;
//基本运算符
public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果  正确 错误 布尔值
        int a=10;
        int b=20;
        int c=21;

        System.out.println(c%a);
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a!=b);
        System.out.println(a==b);

    }
}

package operator;
//基本运算符
public class Demo04 {
    public static void main(String[] args) {
        //++ --

        int a=3;
        int b=a++;//a=a+1;运作代码后，先给b赋值 再自增
        System.out.println(a);
        int c=++a;//运作代码前， 再自增 先给c赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        System.out.println("======");
        //幂运算
        double pow = Math.pow(3,2);
        System.out.println(pow);
    }
}

逻辑运算符

package operator;
//逻辑运算符
public class Demo05{
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a&&b: "+(a&&b));//与 两个都真
        System.out.println("a||b: "+(a||b));//或 一个为真
        System.out.println("!(a&&b): "+!(a&&b));//非   相反

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

    }
}

位运算

package operator;
//位运算
public class Demo06 {
    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);
    }
}

简便运算符

package operator;
//运算符
public class Demo07 {
    public static void main(String[] args) {
        int a=10;
        int b=30;
        a+=b;//a=a+b;
        System.out.println(a);
        a-=b;//a=a-b;
        System.out.println(a);
        System.out.println("=========");
        //字符串连接符
        System.out.println(a+b);
        System.out.println("=========");
        System.out.println(""+a+b);
        System.out.println(+a+b+"");

    }
}

三元运算符

package operator;
//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true 结果为y,否则为z;

        int score = 58;
        String type = score <60 ? "不及格" : "及格";
        System.out.println(type);
    }
}

3 方法和数组

3.1 方法的定义

Java的方法类似与其他语言的函数，是一段用来完成特定功能的代码片段。
方法包含一个方法头和一个方法体
- 修饰符：可选，定义了方法的访问类型，告诉编译器如何调用该方法。
- 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法没有返回值，则returnValueType为关键字void。
- 方法名：是方法的实际名称，方法名与参数表共同构成方法签名。
- 参数类型：像一个占位符。方法被调用时，传递值给参数，该值称为实参或变量。参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数。
  - 形式参数：在方法被调用时用于接收外界输入的数据。
  - 实参：调用方法时实际传给方法的数据。

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

修饰符 返回值类型 方法名（参数类型 参数名,...）{
   方法体...
   return 返回值；
}

3.2 方法的调用

调用方法：对象名.方法名(实参列表)。
Java支持两种调用方法的方式，根据方法是否返回值来选择。
当方法返回一个值的时候，方法调用通常被当成一个值。

int larger = max(30,40);

如果方法返回值是void，方法调用一定是一条语句。
扩展：值传递和引用传递 ( Java都是值传递)。
调用其他类的方法，除非是static静态方法，不然必须实例化这个类(new)

public class Demo01 {
   
    public static void main(String[] args) {
        int add = Demo01.add(1,2); // 通过类名直接调用静态方法
        System.out.println(add); // 3
    }
	// static静态方法，否则就要new实例化来调用
    public static int add(int a,int b){
        return a+b;
    }
}

3.3 方法的重载

重载是在一个类中，有相同的方法名，参数列表不同的方法。
方法重载的规则：
- 方法名称必须相同
- 参数列表必须不同（个数、参数类型、或排序不同）
- 返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载
实现理论
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

3.4 命令行传参

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

public static void main(String[] args) {
    //args.length 数组长度
    for (int i = 0; i < args.length; i++) {
        System.out.println("args["+i+"]: "+args[i]);
    }
}

找到当前类的文件夹，打开cmd.

3.5 可变参数

Jdk1.5开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号 (…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。

//打印最大值
public static void printMax(int... num){
    if(num.length==0){
        System.out.println("没有值传入");
        return;
    }
    int result = num[0];
    for (int i = 1; i < num.length; i++) {
        if(num[i] > result){
            result = num[i];
        }
    }
    System.out.println("最大值是："+result);
}
public static void main(String[] args) {
    printMax(1,2,3,4); //最大值是：4
    printMax(new int[]{1,2,3,4,5}); //最大值是：5
}

3.6 递归

递归就是：A方法调用A方法，自己调用自己！
递归策略只需少量的代码可描述解题过程中多次重复计算，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归结构
- 递归头：什么时候不调用自身方法，没有头将陷入死循环。
- 递归体：什么时候需要调用自身方法。

//阶乘 n! n*(n-1)*...*2*1
public static int f(int n){
    if(n==1) return 1;
    return n*f(n-1); //递归：调用自身
}
public static void main(String[] args) {
    System.out.println(f(5)); //5!= 120
}

4 数组

4.1 数组的定义

数组是相同类型数据的有序集合
数组描述的是相同类型的若干数据，按照一定先后次序排序组合而成
其中，每一个数据称作一个数组元素，每个数组元素可以通过下标访问它们

数组的声明创建

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

dataType[] arrayRefVar; //首选
dataType arrayRefVar[]; //效果相同,但不是首选

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

dataType[] arrayRefVar = new dataType[arraySize]; //int[] nums=new int[10]

数组的元素是通过索引访问的，数组索引从0开始
获取数组长度：arrays.length

int[] nums; //1.声明一个数组
nums = new int[3]; //2.创建一个数组
//3.给数组元素赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
for (int num : nums) { //打印数组所有元素
    System.out.println(num);
}

数组的三种初始化

静态初始化

//静态初始化：创建+赋值
int[] a={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)}

动态初始化

//包含默认初始化
int[] a=new int[2]; //默认值为0
a[0]=1;
a[1]=2;

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

数组的基本特点

1 其长度是确定的，数组一旦被创建，它的大小就是不可改变的。

2 其元素必须是相同类型，不允许出现混合类型。

3 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

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

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

6 数组本身是在堆中的。

4.2 数组的使用

For-Each循环

int[] arrays = {1,2,3,4,5};
//打印全部的数组元素 JDK1.5 没有下标
for (int array : arrays) {
    System.out.println(array);
}

数组作方法入参

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

数组作返回值

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

4.3 多维数组

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

int arr[][] = new int[3][2]; //二维数组,三行两列

int[][] array = {{1,2},{3,4},{5,6}};
//打印二维数组所有元素
for (int i = 0; i < array.length; i++) { //arrays.length=3
    for (int j = 0; j < array[i].length; j++) {
        System.out.print(array[i][j]+" ");
    }
    System.out.println();
}

4.4 Arrays类

数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们使用，但API提供了一个工具类Arrays供我们使用。
Array类中的方法都是static修饰的静态方法，使用时直接使用类名进行调用，可以不用对象调用。
常用功能
- 给数组赋值：fill方法。
- 排序：sort方法，升序。
- 比较数组：equals方法比较数组中元素值是否相等。
- 查找数组元素：binarySearch对排序好的数组进行二分查找法操作。

int[] a = {1,2,3,4,9000,32145,451,21};
System.out.println(a); // [I@28d93b30 (hashcode)

//Arrays.toString 打印数组元素
System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 9000, 32145, 451, 21]

//二分法查找某值 返回下标
System.out.println(Arrays.binarySearch(a, 9000)); // 4

//填充
Arrays.fill(a,2,4,0); //数组[a[2]~a[4])之间填充0
System.out.println(Arrays.toString(a)); //[1, 2, 0, 0, 9000, 32145, 451, 21]

//升序排序
Arrays.sort(a);

冒泡排序

冒泡排序是八大排序最出名的排序算法。
代码：两层循环，外层冒泡轮数，里层依次比较。
当我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)。

//冒泡排序
//1.比较数组中两个相邻的元素，如果第一个数大于第二个数，交换它们位置
//2.每一次比较，都会产生一个最大或最小的数字(升序为最大数)
//3.下一轮则可以少一次排序
//4.依次循环，直到结束
public static int[] sort(int[] array){
    int temp=0;
    //外层循环，次数length-1
    for (int i = 0; i < array.length-1; i++) {
        //内层循环：如果第一个数大于第二个数，交换它们位置
        for (int j = 0; j < array.length-1-i; j++) {
            if(array[j]>array[j+1]){
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
    }
    return array;
}

public static void main(String[] args) {
    int[] a={8,1,35,47,19,-2};
    int[] sort = sort(a);
    System.out.println(Arrays.toString(sort)); //[-2, 1, 8, 19, 35, 47]
}

4.5 稀疏数组

package com.kuang.array;

public class Demo08 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("================");
        int sum = 0;
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if(array1[i][j] != 0){
                    sum ++;
                }
            }
        }
        System.out.println("有效的个数"+sum);
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        int count = 0;
        for (int i=0;i<array1.length;i++){
            for (int j=0;j<array1[i].length;j++){
                if(array1[i][j] != 0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];

                }
            }
        }

        System.out.println("数组");
        for (int i=0;i<array2.length;i++){
            System.out.println(array2[i][0]+"\t"
            +array2[i][1]+"\t"
            +array2[i][2]+"\t");
        }
        System.out.println("=========");
        System.out.println("还原数组");
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        for (int i=1;i<array2.length;i++){
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        System.out.println("输出数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

5 面向对象

5.1 封装

1.属性私有，get/set

package com.opp;


import com.opp.demo04.Student;

/*
    1.提高程序的安全性 ，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统可维护增加了
 */
public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("梁光胜");

        System.out.println(s1.getName());

        s1.setAge(6);//不合法的
        System.out.println(s1.getAge());

    }
}

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

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

    //get获得这个数据
    public String getName() {
        return name;
    }
    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    //alt+insert
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0){//不合法
            this.age = 3;
        }
        this.age = age;
    }
}

5.2 继承

1.extands 继承

-object类

package com.opp;
import com.opp.demo05.Student;
public class Main {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
    }

}

package com.opp.demo05;
//学生 is a 人 派生类 ：子类
public class Student extends Person {
   // ctrl + h

}

package com.opp.demo05;
//老师 is a 人
public class Teacher extends Person{

}

package com.opp.demo05;
//Person 人
public class Person {
    //public
    //protected
    //default
    //private
    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;
    }
}

2.super

package com.opp;
import com.opp.demo05.Person;
import com.opp.demo05.Student;
public class Main {
    public static void main(String[] args) {

        Student student = new Student();
//        student.test("梁光胜");

//        student.test1();

    }

}

package com.opp.demo05;
//Person 人
public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }

    protected  String name = "liang";

        //私有的东西无法被继承
        public void print(){
            System.out.println("Prson");
        }
}

package com.opp.demo05;
//学生 is a 人 派生类 ：子类
public class Student extends Person {
    public Student() {
        super();
        System.out.println("Student无参执行了");
    }


    private String name = "guangsheng";
//    public void test(String name){
//        System.out.println(name);//梁光胜
//        System.out.println(this.name);//guangsheng
//        System.out.println(super.name);//liang
//    }


    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
    public void print(){
        System.out.println("Student");
    }

}

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

VS this:
    代表对象不同
        this: 本身调用者这个对象
        super：代表父亲对象的应用
    前提
        this：没有继承也可以使用
        super： 只能在继承条件下才可以使用
    构造方法
        this() : 本类的构造
        super() : 父类的构造！

3.重写

package com.opp;
import com.opp.demo05.A;
import com.opp.demo05.B;

public class Main {
    //静态方法和非静态方法区别很大
    // 非静态方法 ：方法调用只和左边，定义的数据类型有关
    //非静态:重写
    public static void main(String[] args) {

        A a = new A();
        a.test();//A

        //父类的引用指向子类
        B b = new A();//子类重写了父类的方法
        b.test();//B

    }

}

package com.opp.demo05;

//继承
public class A extends B{
//    public static void test(){
//        System.out.println("A->test()");
//    }

    //@Override重写
    @Override//注释：有功能的注释
    public void test() {
        System.out.println("->test()");
    }
}

package com.opp.demo05;

//重写都是方法的重写，和属性无关
public class B {
//    public static void test(){
//        System.out.println("B->test()");
//    }
    public void test(){
        System.out.println("B->test()");
    }
}

重写；需要有继承关系，子类重写父类的方法
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符，范围可以扩大但不能缩小：public->protected->default->private
    4.抛出的异常：范围 可以缩小 但不能扩大 ClassNotFoundException --> Exception (大)

重写;子类的方法和父类必须一致，方法体不同

为什么需要重写
    1.父类的功能，子类不一定需要，或者不一定满足。

5.3 多态

package com.opp;

import com.opp.demo06.Person;
import com.opp.demo06.Student;

public class Main {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student()
        //new Person()

        //可以指向的引用类型就不确定了，父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        s1.run();//子类重写了的方法，执行子类的方法
        s1.eat();
        ((Student)s2).eat();
    }

}

package com.opp.demo06;

public class Person {

    public void run (){
        System.out.println("run");
    }
}

/*
   package com.opp;

import com.opp.demo06.Person;
import com.opp.demo06.Student;

public class Main {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student()
        //new Person()

        //可以指向的引用类型就不确定了，父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        s1.run();//子类重写了的方法，执行子类的方法
        s1.eat();
        ((Student)s2).eat();
    }

}

 */

package com.opp.demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat() {
        System.out.println("eat");
    }
}
/*
多态注意事项：
    1.多态是方法的多态，属性没有多态
    2.父类和子类有联系，类型转换异常，ClassCastException
    3.存在条件：继承条件，方法需要重写，父类引用指向子类对象
      Father f1 = new Son()

       1,static 方法属于类 它不属于实例
       2.final 常量
       3.private 方法
 */

5.4 instanceof和类型转换

package com.opp;

import com.opp.demo07.Person;
import com.opp.demo07.Student;
import com.opp.demo07.Teacher;

public class Main {
    public static void main(String[] args) {
        //类型之间的转换 基本类型转换
        //父 --》 子

        //高                     低
        Person obj = new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法

        ((Student)obj).go();

        System.out.println("=====");
        Student student  = new Student();
        student.go();

        //子类转换为父类，可能会丢失自己本来的一些方法！
        Person person = student;

    }

}

/*
1.父类引用指向子类对象
2，把子类转换为父类，向上转型
3，把父类转换为子类 ，向下转型 强制转换
4，方便方法的调用，减少重复代码的使用

 */

package com.opp.demo07;

public class Student extends  Person{
    public void go(){
        System.out.println("go");
    }
}


/*
package com.opp;

import com.opp.demo07.Person;
import com.opp.demo07.Student;
import com.opp.demo07.Teacher;

public class Main {
    public static void main(String[] args) {
        //Object > string
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        //System.out.println(x instanceof y); 编译能不能通过 接口

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

        Person person = new Student();
        System.out.println("=========");
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//False
//        System.out.println(person instanceof String);//编译错误

        Student student = new Student();
        System.out.println("=========");
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
//        System.out.println(student instanceof Teacher);//编译错误
//        System.out.println(person instanceof Teacher);//编译错误


    }

}

 */

package com.opp.demo07;

public class Teacher extends Person{

}

package com.opp.demo07;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

5.5类的小总结

/*
    1.类与对象
        类是一个模版：抽象，对象是一个具体的实例
    2.方法
        定义 调用
    3.对应的引用
        引用类型：对象是通过引用来操作的：栈--》堆
        基本类型（8大基本类型）
    4.属性：字段Field 成员变量
        默认初始化：
            数字： 0  0.0
            char :u0000
            boolean : false
            引用   null

            修饰符  属性类型  属性名 = 属性值！
    5.对象的创建和使用
        -必须使用new 关键字创建对象 构造器 Person kuangshen = new Person();
        - 对象的属性 kuangshen.name
        -对象的方法  kuangshen.sleep()
    6.类
        静态的属性  属性
        动态的调用  方法

        封装 继承 多态

 */

5.6 static关键字详解

package com.opp.demo08;

public  final class Person {
    //2.赋初始值
    {
        System.out.println("匿名代码块");
    }
    //1.只执行一次
    static{
        System.out.println("静态代码块");
    }
    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("==========");
        Person person1 = new Person();
    }
}

package com.opp.demo08;
//static:
public class Student {
    private static int age;//静态变量  多线程
    private double score;//非静态变量

    public void run (){
        System.out.println("run");
        go();
    }
    public static void go(){
        System.out.println("go");
    }
    public static void main(String[] args) {
        new Student().run();
        go();


    }

}

package com.opp.demo08;

import static java.lang.Math.PI;
import static java.lang.Math.random;//静态导入包
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

5.7 抽象类

package com.opp.demo09;

//abstract 抽象类 类 extends : 单继承  （接口可以多继承）
public abstract class Action {

    //约束~有人帮我们实现
    //abstract ,抽象方法 只有方法名字，没有方法的实现！
    public abstract  void doSomething();

    //1,不能new这个抽象类，只能靠子类去实现它：约束！
    //2.抽象类里面可以写普通的方法
    //3.抽象方法必须在抽象类中
    // 抽象的抽象  约束

    //new 存在构造器不
    //存在 的意义

}

package com.opp.demo09;

//抽象类的所有方法继承了他的子类，都必须要实现他的方法，除非~
public class A extends Action{
    public void doSomething(){

    }
}

5.8 接口

接口作用

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

package com.opp.demo10;

public interface TimeService {
    void timer();
}

package com.opp.demo10;

//interface定义的关键字
public interface UserService {
    //接口中的定义其实都是抽象的public abstract

    //属性~ 常量 public static final
    int age = 99;
    void  add(String name);
    void  delete(String name);
    void  update(String name);
    void  query(String name);

}

package com.opp.demo10;

//抽象类 extends~
//类 可以实现接口 implements 接口
//实现了接口的类需要重写接口中的方法

//多继承~利用接口来实现多继承
public class UserServiceimpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void timer() {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

N种内部类

package com.opp;

import com.opp.demo11.Outer;

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();

        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
        outer.out();
    }

}

package com.opp.demo11;

public class Outer {

    private int id=1000;
    public void out(){
        System.out.println("这个是外部类的方法");
    }

    public class  Inner{
        public void in(){
            System.out.println("这个是内部类的方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

package com.opp.demo11;

public class Test {
    public static void main(String[] args) {
        new Apple().eat();
        
        new UserService(){
            @Override
            public void hello() {
                
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface  UserService{
    void hello();
}

5.9 异常

package com.exception.demo01;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(11/0);
        new Demo01().a();
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}


package com.exception.demo01;

public class Test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try{//try 监控区域
            if(b==0){//throw throws
                throw new ArithmeticException();//主动抛出异常
            }

            System.out.println(a/b);
        }catch (ArithmeticException e){//catch 捕获异常
            System.out.println("finally");
        }catch (Error e){
            System.out.println("fially111");
        }
        finally{//处理善后工作
            System.out.println("结束");
        }

        //catch 先小后大
        //finally 可以不要finally
    }


}
// // Ctrl + alt + t



package com.exception.demo01;

public class Test2 {
    public static void main(String[] args) {
        try {
            new Test2().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
        }

    }
    //假设这方法中，处理不了这个异常，方法抛出异常
    public void test(int a,int b)throws ArithmeticException{
        if(b==0){//throw throws
            throw new ArithmeticException();//主动抛出异常
        }
    }


}
// // Ctrl + alt + t

package com.exception.demo02;

//自定义异常
public class MyException extends Exception{
        private int detail1;
        public MyException(int a){
            this.detail1 = a;
        }

    @Override
    public String toString() {
        return "MyException{" +
                "detail1=" + detail1 +
                '}';
    }
}



package com.exception.demo02;

public class Test {
    public static void main(String[] args) {
        try {
            test(12);
        } catch (MyException a) {
            System.out.println("MyException=>"+a);
        } finally {
        }
    }
    static void test(int a)throws MyException{
        System.out.println("传递的参数为"+a);
        if (a>10){
            throw new MyException(a);
        }
        System.out.println("Ok");
    }
}