java基础学习

最新推荐文章于 2024-07-12 15:51:39 发布

suncanshine

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量693

点赞数

文章标签： java java-ee idea

本文链接：https://blog.csdn.net/suncanshine/article/details/124519055

版权

Java基础学习

Java基础

Java特征

简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性

Java三大版本

JavaSE ：标准版（桌面程序，控制台开发）

~~JavaME：嵌入式开发（手机，小家电）~~

JavaEE：企业级开发（Web端，服务器）

JDK、JRE、JVM

JDK：Java Development Kit

JRE：Java Runtime Environment

JVM：Java Virtual Machine

注释：单行、多行、文档注释

关键字与标识符

关键字：
在这里插入图片描述

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

数据类型

基本类型：整数类型（byte 1 short 2 int 4 long 8）、浮点类型（float 4、double 8）、字符类型（char 2）；boolean类型

引用类型：类、接口、数组

String不是关键字，是类

位：计算机内部数据存储的最小单位

字节：计算机中数据处理的基本单位 B 1B=8bit

字符：计算机中使用的字母、数字、字和符号

1KB=1024B 1M=1024KB 1G=1024M

所有的字符本质还是数字

类型转换

低—高：byte,short,char→int→long→float→double

1.不能对布尔值进行转换

2.不能把对象类型转换为不相干的类型

3.在把高容量转换到低容量的时候，强制转换

4.转换的时候可能存在内存溢出和精度问题

变量和常量

变量

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

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

变量作用域： 类变量、实例变量、局部变量

public class Variable{
    static int allClicks=0; //类变量 static
    String str="hello world"; //实例变量 从属于对象
    
    public void method(){
        int i=0; //局部变量 必须声明和初始化值
    }
}

常量

初始化后不能再改变值，不会变动的值

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

常量名一般使用大写字符

final 常量名=值;
final double PI=3.14;

命名规范：
在这里插入图片描述

ctrl+D：复制当前行到下一行

Java流程控制

Scanner对象

通过Scanner类来获取用户的输入

Scanner s=new Scanner(System.in);

next()

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

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

        //判断用户有没有输入字符串
        if (scanner.hasNext ()){
            String str=scanner.next ();
            System.out.println ("输入的内容为"+str);
        }
        scanner.close ();
    }
}

nextLine():

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

public class Demo2 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner (System.in);
        System.out.println ("使用nextLine方式接收：");

        if(scanner.hasNextLine ()){
            String str=scanner.nextLine();
            System.out.println ("输出的内容为："+str);

        }
        scanner.close ();
    }
}

public class Demo3 {
    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 ();
            m=m+1;
            sum=sum+x;
        }
        System.out.println (m+"个数的和为"+sum);
        System.out.println (m+"个数的平均值是"+(sum/m));
        scanner.close ();
    }
}

选择结构

if单选择结构

if双选择结构

if多选择结构

嵌套的if结构

switch多选择结构

循环结构

while 先判断后执行

do…while 至少会执行一次先执行后判断

for循环

for(int i=1;i<=100;i++){
    System.out.println(i);
}
//idea快捷键 100.for

public class ForDemo01 {
    public static void main(String[] args) {
        //计算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);
    }
}

public class ForDemo02 {
    public static void main(String[] args) {
        //用while或for循环输出1-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 ();
            }
        }
    }
}

println 输出完会换行

print 输出完不会换行

public class ForDemo {
    public static void main(String[] args) {
        //打印9*9乘法表
        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 ();
        }
    }
}

break 终止循环，不执行剩余的语句 continue 终止某次循环，接着进行下一次的判定 (break 辞职，contine 休假一天)

public class TestDemo {
    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 ();
        }
    }
}

Java方法

何谓方法

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

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

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

方法的定义

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

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

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

返回值类型：方法可能会有返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。

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

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

形式参数：在方法被调用时用于接受外界输入的数据。

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

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

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

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

        //实际参数：实际调用传递给他的参数
        int sum=add(9,9);
        System.out.println (sum);
    }

    //加法
    //形式参数，用来定义作用的
    private static int add(int a, int b) {
        return a+b;
    }
}

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

    public static int max(int num1,int num2){
       int result=num1;
       if(num1 == num2){
           System.out.println ("num1==num2");
           return 0;//终止方法
       }
        if(num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
}

方法调用

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

Java支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当做一个值。比如：

int larger = max(30,40);

如果方法返回值是void，方法调用一定是一条语句

System.out.println("Hello,pipijia!");

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法的重载的规则：

方法名称必须相同
参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
方法的返回类型可以相同也可以不相同
仅仅返回类型不同不足以成为方法的重载

实现理论

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

可变参数

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

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

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

public class Demo04 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax (34,3,3,2,9,90.9);
        printMax (new double[]{1,3,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);
    }

}

递归(★)

递归就是A方法自己调用自己

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

递归结构包括两个部分：

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

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

public class Demo05 {
    public static void main(String[] args) {
        System.out.println (f (5));
    }
    //1! 1
    //2! 2*1
    public static int f(int n){
        if(n==1){
            return 1;
        }else {
            return  n*f(n-1);
        }
    }
}

数组

数组的定义

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

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

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

数组声明创建

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

dataType[] arrayRefVar; //首选的方法
或
dataType arrayRefVar[]; //效果相同，但不是首选方法

Java语言使用new操作符来创建数组

dataType[] arrayRefVar=new dataType[arraySize];

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

获取数组长度：

arrays.length

public class ArrayDemo01 {
    //变量的类型 变量的名字=变量的值；
    //数组类型
    public static void main(String[] args) {
        int[] nums;//1.声明一个数组
        nums=new int[10];//2创建一个数组     这里面可以存放10个int类型的数字
        //int[] num=new int[10];

        //3.给数组中元素赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;

        //计算所有元素的和
        int sum=0;
        //获取数组长度：arrays.length
        for(int i=0;i< nums.length;i++){
            sum=sum+nums[i];
        }
        System.out.println (sum);
    }
}

三种初始化

静态初始化

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;

数组的默认初始化：

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

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化
        int[] a={1,2,3,4,5,6,7,8};
        System.out.println (a[0]);

        //动态初始化：包含默认初始化
        int[] b=new int[10];
        b[0]=9;
        System.out.println (b[1]);
    }
}

数组的基本特点

其长度是确定的，数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

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

数组使用

For-Each循环
数组作为方法入参
数组作返回值

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};

        //打印全部的数组元素
        for (int i=0;i<arrays.length;i++){
            System.out.println (arrays[i]);
        }
        System.out.println ("-----------");

        //计算所有元素的和
        int sum=0;
        for (int i=0;i<arrays.length;i++){
            sum+=arrays[i];
        }
        System.out.println ("sum="+sum);
        System.out.println ("-----------");


        //查找最大元素
        int max=arrays[0];
        for(int i=1;i < arrays.length;i++){
            if(arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println ("max="+max);
    }
}

增强for循环：

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};

        //For-Each循环
//        for (int array : arrays) {
//            System.out.println (array);
//        }

       // 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){
        int[] result=new int[arrays.length];

        //反转的操作
        for (int i = 0,j=result.length-1; i <arrays.length; i++,j--) {
            //result[]=arrays[i];
            result[j]=arrays[i];
        }

        return  result;
    }
}

多维数组

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

二维数组

int a[][]=new int[2][5]; //两行五列的数组

public class ArrayDemo05 {
    public static void main(String[] args) {
        //[4][2]
        /*
        1,2 array[0]
        2,3 array[1]
        3,4 array[2]
        4,5 array[3]
         */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        //System.out.println (array[0]);
        printArray (array[0]);  //1,2
        System.out.println (array[1][0]);  //2
        System.out.println (array.length); //4
        System.out.println (array[0].length); //2

        //输出数组的所有元素
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]);
            }
        }
    }

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

Array类

数组的工具类java.util.Arrays

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（“不用”，不是“不能”）

给数组赋值：fill方法

给数组排序：sort方法，升序

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

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a={1,2,3,90,9999,3456,214,3,5};
        System.out.println (a);
        //打印数组元素
        System.out.println (Arrays.toString (a));
        Arrays.sort (a);//排序，升序
        System.out.println (Arrays.toString (a));

        Arrays.fill (a,2,4,0);// 填充数组，将a[2]到a[4]的元素值设为0

        Arrays.fill (a,0);//填充，将数组元素全部设置为0
        System.out.println (Arrays.toString (a));
    }
}

冒泡排序

时间复杂度O(n2)

import java.util.Arrays;

//冒泡排序
//1.比较数组中两个相邻的元素，如果前一个比后一个大，就交换它们两个
//2.每一次比较都会产生一个最大或者最小的数字
//3.下一轮则可以少一次排序
//4.依次循环，直到结束！
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5, 7, 8, 99, 34, 64, 19};
        int[] sort = sort (a);
        System.out.println (Arrays.toString (sort));
    }

    public static int[] sort(int[] array) {
        int temp = 0;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] > array[j]) { //if (array[j+1] < array[j])小的在前
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }

}

稀疏数组

编写五子棋游戏中，有存盘退出和续上盘的功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ku3KDQRB-1651324934669)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20220409140151949.png)]

因为该二维数组的很多默认值0，因此记录了很多没有意义的数据——使用稀疏数组

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

稀疏数组处理方式：

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

如图，左边是原始数组，右边是稀疏数组。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gMU6nzzk-1651324934670)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20220409140639231.png)]

增强for循环：for(声明语句：表达式) {}

声明语句是声明新的局部变量，表达式是要访问的数组。

public class ArrayDemo08 {
    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 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;

        //遍历二维数组，将有效值的值放入稀疏数组
        int conut=0;
        for(int i=0;i<array1.length;i++){
            for(int j=0;j<array1[i].length;j++){
                if(array1[i][j]!=0){
                    conut++;
                    array2[conut][0]=i;
                    array2[conut][1]=j;
                    array2[conut][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 ("还原");
        //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 ();
        }
}
}

面向对象

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

面向对象编程（Object-Oriented Programming,OOP) 本质就是：**以类的方式组织代码，以对象的组织（封装）数据。 ** 抽象

三大特征：封装继承多态

从认识论角度考虑是现有对象后有类。对象，是具体的事情。类是抽象的

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

回顾方法及加深

方法的定义

修饰符
返回类型
break：跳出switch，结束循环和return的区别
方法名：注意规范就ok 见名知意
参数列表：（参数类型，参数名）…
异常抛出

方法的调用

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

    }

    /*
    修饰符 返回值类型 方法名（……）{
    //方法体
    //return 返回值
    }
     */
    public String sayHello(){
        return "Hello";
    }
    public int max(int a,int b){
        return a>b?a:b; //三元运算符
    }
}

方法的调用

静态方法
非静态方法
形参和实参
值传递和引用传递
this关键字

//值传递
public class Demo03 {
    public static void main(String[] args) {
        int a=5;
        System.out.println (a);//5
        Demo03.change (a);
        System.out.println (a);//5
    }

    //返回值为空
    public static void change(int a){
        a=10;
    }
}

//引用传递
public class Demo04 {
    public static void main(String[] args) {
    Person person = new Person();
        System.out.println (person.name); //null

        Demo04.change(person);

        System.out.println (person.name); //Tom



    }

    public static void change(Person person){
        person.name = "Tom";
        //person是一个对象，指向的 Person person = new Person();这是一个具体的人，可以改变它的属性
    }
}

class Person {
    String name;
}

类与对象的关系

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

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

创建与初始化对象

使用new关键字创建对象

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

public class Student {
    String name;
    int age;
    //方法
    public void study() {
        System.out.println("学生学习");
    }
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
    //类：抽象的，实例化
    //类的实例化后会返回一个自己的对象
    //student对象就是一个student类的具体实例    
        Student xiaoming = new Student ();
        Student xiaohong = new Student ();

        xiaoming.name="小明";
        xiaoming.age=18;

        System.out.println (xiaoming.name);
        System.out.println (xiaoming.age);

        xiaohong.name="小红";
        xiaohong.age=19;

        System.out.println (xiaohong.name);
        System.out.println (xiaohong.age);
    }
}

构造器

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

1.必须和类的名字相同

2.必须没有返回类型，也不写void

public class Person {
//一个类即使什么都不写，它也会有一个默认的构造方法
    //显示的定义构造器
    String name;

    //实例化初始值
    //1.使用new关键字，本质上是调用了构造器
    //2.用来初始化值
    public Person(){
        this.name = "Tom";
    }

    //有参构造：一旦定义了有参构造，无参就必须显式定义
    public Person(String name){
        this.name = name;
    }
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        Person person = new Person ();
        Person person1 = new Person ("jiajia");
        System.out.println (person.name);

    }
}

alt+insert：自动生成有参无参构造

封装

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

封装的意义：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护增加了

public class Student {
    //属性私有
    private String name;//姓名
    private int id; //学号
    private char sex; //性别
    private int age; //年龄

    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法
    //get 获得这个数据

    public String getName() {
        return this.name;
    }

    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;
    }

    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0 && age < 150) {
            this.age = age;
        }else {
            this.age=3;
        }
        this.age = age;
    }
}

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName ("张三");
        System.out.println (s1.getName ());
    }
}

继承

public class Person {

    public Person(){
        System.out.println ("person无参执行了");
    }
    protected String name="jiajia";

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

public class Student extends Person {
    public  Student(){
        //隐藏代码
        super ();//super(); 调用了父类的构造器，必须要在子类的第一行
        System.out.println ("Student无参执行了");
    }

    //super(); 调用了父类的构造器，必须要在子类的第一行


    private String name="qin";

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

    public void test(String name){
        System.out.println (name);
        System.out.println (this.name);
        System.out.println (super.name);
    }
}

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        //student.test ("a");
        student.test1 ();
    }
}

super注意点

super调用父类的构造方法，必须在构造方法的第一个

super必须只能出现在子类的方法或者构造方法中

super和this不能同时调用构造方法

super vs this

代表的对象不同：this本身调用者这个对象，super：代表父类对象的应用

前提：this没有继承也可以使用，super只能在继承条件下才可以使用

构造方法：this（）本类的构造 super（）父类的构造

方法重写

public class B {
//    public static void test() {
//        System.out.println("B=>test");
//    }
        public  void test() {
        System.out.println("B=>test");
    }
}

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

    @Override
    public void test() {
        System.out.println("A=>test");
    }
}

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

        //静态方法和非静态方法区别很大
        //静态方法：方法的调用只和左边定义的数据类型有关 static
        //非静态方法：重写
        A a=new A();
        a.test();

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

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

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，但不能缩小 public>Protected>Default>private
抛出的异常：范围可以被缩小，但不能被扩大

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

为什么需要重写：

父类的功能，子类不一定需要，或者不一定满足

Alt+Insert：override

多态

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

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件：

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

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

public class Student extends Person {
    @Override
    public void run() {
        System.out.println ("student run");
    }

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

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

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

        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2=new Student();
        Object s3=new Student();

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

多态注意事项：

多态是方法的多态，属性没有多态性。
父类和子类要有联系否则类型转换异常 ClassCastException
存在条件：继承关系，方法需要被重写，父类引用指向子类对象。

Father f1=new Son();

不能被重写：

static 方法，属于类不属于实例
final 常量
private方法

instanceof和类型转换

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

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

public class Teacher extends Person {
}

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

        //类型之间的转换
        //高                    低
        Person obj = new Student ();
        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        Student student = (Student) obj;
        student.go ();
        ((Student) obj).go ();

        //子类转父类可能会丢失自己本来的一些方法


        //instanceof 运算符
//        //object>person>student
//        //object>person>teacher
//        //object>string
//        Object  object = new Student ();
//
//        //System.out.println (X instanceof Y);能不能编译通过看X 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
//
//        System.out.println ("===========================");
//        Person  person = new Student ();
//        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);//编译报错，没有关系，不能比较转换
//
//        System.out.println ("===========================");
//        Student  student = new Student ();
//        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 (student instanceof String);//编译报错，没有关系，不能比较转换
    }
}

父类引用指向子类的对象
把子类转换为父类，向上转型
把父类转换为子类，向下转型，强制转换
方便方法的调用，减少重复的代码。简洁

抽象类

//abstract 抽象类
public abstract class Action {

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

package oop.Demo07;

public class A extends Action{
    @Override
    public void doSomething() {

    }
}

不能new抽象类，只能靠子类去实现它：约束
抽象类中可以写普通的方法
抽象方法必须在抽象类中

接口

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范！自己无法写方法专业的约束。约束和实现分离：面向接口编程

//接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的  public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void timer();
}

//类可以实现接口 implements接口
//实现了接口的类就需要重写接口中的方法
//多继承——用接口实现
public class UserServiceImpl implements UserService, TimeService {

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口的作用：

约束
定义一些方法，让不同的人实现
public abstract
public static final
接口不能被实例化，接口中没有构造方法
implements可以实现多个接口
必须要重写接口中的方法

异常

Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类 Error Exception

在这里插入图片描述

ctrl+alt+t 捕获异常

在这里插入图片描述

I/O流

在这里插入图片描述
是跟着b站的狂神学的，然后一步一步记的笔记。讲的真的很好。java完整学习路线：https://www.bilibili.com/read/cv5702420?spm_id_from=333.1007.0.0
java基础：https://www.bilibili.com/video/BV12J41137hu
有时间的童鞋可以跟着学一遍