Java基础语法学习整理

最新推荐文章于 2024-07-17 17:57:52 发布

yangsc6

最新推荐文章于 2024-07-17 17:57:52 发布

阅读量274

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/ysc666/article/details/106525317

版权

基础语法

1.HelloWorld

public class HelloWorld {
    public static void main(String[] args) {
        //输出一个Hello world！
        System.out.println("Hello world!");
    }
}

2.数据类型扩展

public class Demo02 {
    public static void main(String[] args) {
        //整数扩展
        int data1 = 10;
        int data2 = 010;
        int data3 = 0b000100;
        int data4 = 0x10;

        System.out.println(data1);
        System.out.println(data2);
        System.out.println(data3);
        System.out.println(data4);
        System.out.println("========================");
        //浮点数扩展 银行业务用Bigdecimal
        float f1 = 0.1f;
        double f2 = 1.0 / 10;
        float d1 = 1314324143f;
        float d2 = d1 + 1;

        System.out.println(f1 == f2);
        System.out.println(d1 == d2);
        System.out.println(f1);
        System.out.println(f2);

        System.out.println("========================");
        //字符扩展
        char c1 = '哈';
        char c2 = '1';
        char c3 = '\u0061';

        System.out.println((int)c1);
        System.out.println((int)c2);
        System.out.println(c3);

        System.out.println("Hello\tWorld!");

    }
}

3.数据类型强制转换

public class Demo03 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;   //强制转换

        System.out.println(i);
        System.out.println(b);

        System.out.println("===================");
        System.out.println((int)13.8);
        System.out.println((int)-65.89f);

        System.out.println("===================");
        char c = '1';
        int data = c + 1;
        System.out.println((int)c);
        System.out.println(data);

        System.out.println(c);
        System.out.println((char)data);
    }
}

4.变量&常量

public class Demo04 {
    //属性：变量

    //类变量
    static double month = 2;
    //常量
    //修饰符 修饰符 数据类型 变量名
    //修饰符 不存在先后顺序
    static final  double TIME = 2020;

    //实例变量，从属于对象。方法之外，类之内。
    //如果不初始化，这个类型的值默认为 0.0.0
    //布尔值：默认为false
    //除了基本类型，其它都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量
        int a = 1;
        System.out.println(a);

        //实例变量
        Demo04 d04 = new Demo04();
        System.out.println(d04.age);
        System.out.println(d04.name);

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

        //常量
        System.out.println(TIME);
    }

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

    }
}

5.运算符

package operator;

public class Demo02 {
    public static void main(String[] args) {
        int a = 3;
        int b = a++;
        int c = ++a;
        double mul ;
        boolean m = true;
        boolean n = false;

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

        mul = Math.pow(4, 2);
        System.out.println(mul);

        System.out.println("m&&n:" + (m && n));
        System.out.println("m||n:" + (m || n));
        System.out.println("!(m&&n):" + !(m && n));
    }
}
## 6.字符串拼接

```java
public class StringCat {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        //字符串在前拼接，直接拼接输出字符串
        //字符串在后拼接，先计算再拼接输出字符串
        System.out.println("" + a + b);     //1020
        System.out.println(a + b + "");     //30
    }
}

7.包机制

为了能够更好的组织类，Java提供了包机制，用于区别类名命名空间。
package pkg1[. pkg2[. pkg3…]];
为了能够使用某一个包的成员，需要在Java程序中明确导入改包，使用import语句完成该功能。
import pkg1[. pkg2[. pkg3…]];
一般用公司域名倒置为包名
例如package com.baidu.www

package com.ysc.base;	//包名

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

public class StringCat {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        //字符串在前拼接，直接拼接输出字符串
        //字符串在后拼接，先计算再拼接输出字符串
        System.out.println("" + a + b);     //1020
        System.out.println(a + b + "");     //30
    }
}

8.Scanner对象

Scanner类为java提供的工具类，我们可以用Scanner类来获取用户的输入。基本语法为

Scanner scanner = new Scanner(System.in);

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

scanner对象的两种接收输入方法：
next()

一定是读取到有效字符后才可以结束输入。
next()方法不能得到带有空格的字符串。

package com.ysc.scanner;

import java.util.Scanner;

public class DemoScanner {
    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("next方式的输入内容为："+str);
        }
        //IO流的类如果不关闭会一直占用资源，用完就要关闭。
        scanner.close();
    }

}

nextLine()

Enter输入作为结束符，能够获取到Enter之前的所有输入字符

package com.ysc.scanner;

import java.util.Scanner;

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

        if(scanner1.hasNextLine()){
            //使用nextLine接收
            String str1 = scanner1.nextLine();
            System.out.println("nextLine方式的输入内容为："+str1);
        }
        //IO流的类如果不关闭会一直占用资源，用完就要关闭。
        scanner1.close();

    }
}

package com.ysc.scanner;

import java.util.Scanner;

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

        scanner.hasNextLine();
        //使用nextLine接收
        String str1 = scanner.nextLine();
        System.out.println("输入内容为：\n" + str1);

        //IO流的类如果不关闭会一直占用资源，用完就要关闭。
        scanner.close();
    }
}

9.求输入数字的和与平均值

package com.ysc.scanner;

import java.util.Scanner;

public class DemoScannerSumAndAvrg {
    public static void main(String[] args) {
        //输入多个数，并求其和与平均值，每输一个数字用回车确认，通过输入非数字符结束并输入结果
        double sum = 0;
        double temp = 0;
        int num = 0;
        double avrg = 0;

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入需要求和与平均数的数字：");
        while(scanner.hasNextDouble()) {
            temp = scanner.nextDouble();
            num++;
            sum = sum + temp;
        }
        avrg = sum / num;

        System.out.println("共输入的数字个数为：" + num);
        System.out.println(num + "个数字和为：" + sum);
        System.out.println(num + "个数字的平均值为：" + avrg);

        scanner.close();
    }
}

10.反编译

java----class（字节码文件）----反编译（IDEA）
把class文件copy到java文件夹下

11.流程控制

if 语句、switch语句、whil语句、dowhile语句、for循环

package com.ysc.struct;

public class ProcessCtrlDemo {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        int esum = 0;
        int osum = 0;

        System.out.println("=======if--else=======");
        if(i == 0){
            System.out.println("Init i:" + i);
        }else{
            System.out.println("Error!");
        }

        System.out.println("=======while=======");
        //for(i = 1; i <= 100; i++){
        while(i < 100){
            i++;
            sum += i;
            System.out.println(i);
        }
        System.out.println("1+2+3+...+100="+sum);

        System.out.println("=======do--while=======");

        do{
            System.out.println(i);
        }while(i > 100);

        System.out.println("=======for=======");
        //计算0-100之间所有奇数和偶数的和

        for(int k = 0; k <= 100; k++)
        {
            //计算0~100所有偶数的和
            if((k % 2 ) == 0){
                esum += k;
            }else {     //计算0~100所有奇数的和
                osum += k;
            }
        }

        System.out.println("0~100所有偶数的和为：" + esum);
        System.out.println("0~100所有奇数的和为：" + osum);

        //输出1~1000中能被5整除的数，并且每行输出3个

        for (int i1 = 0, j = 0; i1 < 1000; i1++) {
            if((i1 % 5) == 0){
                if(j < 3){
                    j++;
                    System.out.print(i1 + " ");
                }else {
                    j = 0;
                    System.out.println();
                }
            }
        }

        //输出九九乘法表

        for (int m = 1; m <= 9; m++) {
            for(int n = 1; n <= m; n++){
                System.out.print(n + " * " + m + " = " + m * n + "\t");
            }
            System.out.println();
        }

        //增强型for循环----jdk5引入，重点是用于数组和集合的

        int[] arry = {100, 1000, 10000, 100000, 1000000};

        for(int a : arry){
            System.out.println(a);
        }

        //打印101到150之间所有的质数----标签不建议使用

        skip:for(int x = 101; x <= 150; x++){
            for(i = 2; i < x; i++){
                if(x % i == 0){
                    continue skip;
                    //break;
                }
            }
            //if(i == x){
                //System.out.println(x);
            //}
            System.out.print(x + "\t");
        }

    }
}

12.打印三角形

五行的*三角形实现

package com.ysc.struct;

import java.util.Scanner;

public class TriangleDemo {
    public static void main(String[] args) {
        int i = 0;
        int j = 0;
        int n = 0;
        //默认所有三角形都是n行n列

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入三角形的行数：");

        n = scanner.nextInt();

        //直角三角形,直角在左下边
        for(i = 0; i < n; i++){
            for(j = 0; j < i + 1; j++){
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println();


        //直角三角形，直角在右下边
        for(i = 0; i < n; i++){
            for(j = 0; j < n - 1 - i ; j++){
                System.out.print(" ");
            }
            for(j = 0; j < i + 1; j++){
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println();


        //直角三角形，直角是在左上边
        for(i = 0; i < n; i++){
            for(j = 0; j < n - i ; j++){
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println();


        //直角三角形，直角是在右上边
        for(i = 0; i < n; i++){
            for(j = 0; j < i ; j++){
                System.out.print(" ");
            }
            for(j = 0; j < n - i; j++){
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println();

        //角在上边的等边三角形
        for(i = 0; i < n; i++){
            for(j = 0; j < n - i - 1; j++){
                System.out.print(" ");
            }
            for(j = 0; j < i + 1; j++){
                System.out.print("*");
            }
            for(j = 0; j < i; j++){
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println();

        //角在下边的等边三角形
        for(i = 0; i < n; i++){
            for(j = 0; j < i; j++){
                System.out.print(" ");
            }
            for(j = 0; j < n - i; j++){
                System.out.print("*");
            }
            for(j = 0; j < n - i - 1; j++){
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println();
    }
}

在这里插入图片描述

13.方法的重载

方法是语句的集合，他们在一起执行一个功能。
方法是解决一类步骤的有序集合，包含于类或对象中，在程序中被创建，在其他地方被引用。
重载就是在同一个方法中，方法名相同，但形参不同的方法
规则：
1 必须在同一个类中

2 方法名相同

3 方法的参数的个数、顺序或类型不同

4 与方法的修饰符和或返回值没有关系

package com.ysc.method;

public class ReloadDemo {
    public static void main(String[] args) {
        double sum = 0;
        double sum1 = 0;
        sum = test(10, 10);
        sum1 = test(10.0, 10, 10);
        System.out.println("sum="+sum);
        System.out.println("sum1="+sum1);

    }

    public static  int test(int a, int b){
        System.out.println("test(int, int) -- add");
        return a + b;
    }

    public static  double test(double a, int b, int c){
        System.out.println("test(double, int, int) -- add");
        return (double)(a + b + c);
    }
}

在这里插入图片描述

14.命令行传参及可变参数

命令行传参

package com.ysc.method;

public class CmdTranPara {
    public static void main(String[] args) {
        for(int i = 0; i < args.length; i++){
            System.out.println("agrs[" + i + "] is " + args[i]);
        }
    }
}

在这里插入图片描述
可变参数
在方法声明中，在指定参数类型后加一个省略号（…）
一个方法中必须只有一个可变参数，任何普通参数必须在它之前进行声明。

package com.ysc.method;

public class VeriablePara {
    public static void main(String[] args) {
        VeriablePara veriablePara = new VeriablePara();
        veriablePara.test(1,2,3,4,5);
        printMaxValue(10, 30, 22, 199, 36);
    }
    public  void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);

    }
    public static void printMaxValue(double... elements){
        if(elements.length == 0){
            System.out.println("No members of elements!");

        }
        double max = elements[0];
        System.out.print(elements[0] + " ");

        for(int i = 1; i < elements.length; i++){
            System.out.print(elements[i] + " ");
            if(max < elements[i]){
                max = elements[i];
            }
        }
        System.out.println();
        System.out.println("the max element of array is " + max);
    }
}

在这里插入图片描述

15.递归

递归就是方法自己调用自己，利用递归可以用简单的办法来解决复杂的问题，递归的能力在于用有限的语句来定义对象的无限集合。
递归有两个部分：
递归头：什么时候不调用自己。如果没有头，将陷入死循环。
递归体：什么时候需要调用自己。

package com.ysc.method;

import java.util.Scanner;

public class Recursive {
    public static void main(String[] args) {
        int n;

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入需要计算阶乘的数字：");
        n = scanner.nextInt();

        if(n < 1){
            System.out.println("输入错误！");
            return;
        }

        System.out.println(factorial(n));
    }
    //n! n的阶乘
    public static int factorial(int n){
        if(n == 1){
            return 1;
        }else{
            return n * factorial(n - 1);
        }
        
    }
}

在这里插入图片描述

16.数组

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

package com.ysc.array;

public class Array {
    public static void main(String[] args) {
        int i = 0;
        //int[] array;    //声明

        //array = new int[10];    //创建

        int[] array = new int[10];  //声明&创建

        for(i = 0; i < array.length; i++){
            array[i] = i;
            System.out.println("array[" + i + "] = " + i);
        }
    }
}

在这里插入图片描述
二维数组、for-each循环

package com.ysc.array;

import java.util.Arrays;

public class SparseArray {
    public static void main(String[] args) {
        int sum = 0;
        int count = 0;
        int[][] array = new int[11][11];


        array[1][2] = 1;
        array[2][3] = 2;

        //打印二维数组
        printArrays(array);

        //转换为稀疏数组保存，并输出
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array[i][j] != 0){
                    sum++;
                }
            }
        }
        //创建稀疏数组---行列值
        int[][] array1 = new int[sum+1][3];
        //打印第一行
        array1[0][0] = 11;
        array1[0][1] = 11;
        array1[0][2] = sum;
        //打印剩余行
        for (int i = 0; i < array.length; i++) {
            //打印每一行
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    count++;
                    array1[count][0] = i;
                    array1[count][1] = j;
                    array1[count][2] = array[i][j];
                }
            }
        }
        System.out.println("打印稀疏数组");
        printArrays(array1);

        //创建还原稀疏数组
        int[][] backArray = new int[array1[0][0]][array1[0][1]];

        for (int i = 1; i < array1.length; i++) {
            backArray[array1[i][0]][array1[i][1]] = array1[i][2];
        }
        //打印还原的稀疏数组
        for (int[] ints : backArray) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
    //打印二维数组
    public static void printArrays(int[][] arrays){
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }
    }
}

在这里插入图片描述

17.面向对象编程

（Object-Oriented Programming）
面向对象及面向过程的意思：
面向过程：
步骤清晰简单，第一步做什么，第二步做什么…

面向对象：
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些问题进行单独思考。最后，在对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

面对对象编程的本质就是：以类的方式组织代码，以对象的形式组织数据。

核心思想为抽象

三大特性
封装
继承
多态

对象，是具体的事物。类，是抽象的事物。
从代码运行角度考虑是现有类后有对象，类是对象的模板。

18.属性

19.构造

java中的构造方法是一种特殊的方法，用于初始化对象。java构造函数在对象创建时被调用。它构造值，即提供对象的数据。

构造器：
和类名相同、没有返回值。
作用：
new本质在调用构造方法，初始化对象的值
注意点：
定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造。

构造函数与普通函数的区别：

一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。
构造函数是在对象建立时由 jvm 调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。
普通函数可以使用对象多次调用，构造函数就在创建对象时调用。
构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。
构造函数没有返回值类型。

构造函数要注意的细节：

当类中没有定义构造函数时，系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义了构造函数，这时默认的构造函数就没有了。备注：可以通过 javap 命令验证。
（在一个类中可以定义多个构造函数，以进行不同的初始化。多个构造函数存在于类中，是以重载的形式体现的。因为构造函数的名称都相同。

package com.ysc.oop;

public class Application {
    public static class Student{
        String name;
        int age;

        //默认构造，无参
        public Student(){
            this.name = "ysc";
            this.age = 1;
            System.out.println("this is Student();");
        }

        //有参构造，重载1
        public Student(String name, int age){
            this.name = name;
            this.age = age;
            System.out.println("this is Student(String, int);");
        }
        //有参构造，重载2
        public Student(String name, int age, int num){
            this.name = name;
            this.age = age;
            System.out.println("this is Student(String, int, int);");
        }

    }
    public static void main(String[] args) {
        Student student = new Student();
        Student student1 = new Student("小老弟",1);
        Student student2 = new Student("小老妹",2, 0);

        System.out.println("===========================");
        System.out.println(student.name);
        System.out.println(student.age);

        System.out.println("===========================");
        System.out.println(student1.name);
        System.out.println(student1.age);

        System.out.println("===========================");

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

在这里插入图片描述

20.面对对象的三大特性，封装、继承、多态。

封装
程序设计追求高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉。低耦合就是仅暴露少量的方法给外部使用。
数据的隐藏，通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有，get/set

package com.ysc.oop;

public class Pack {
    //属性私有，封装性
    private String name;
    private int age;

    //alt+insert快捷键可以直接打出
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.ysc;

import com.ysc.oop.Pack;

public class TestApplication {
    public static void main(String[] args) {
        int m = 0;

        int[][] array = new int[6][6];

        System.out.println("=============");
        System.out.println("赋值前");
        printArray(array);

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = 6;
            }
        }

        System.out.println("=============");
        System.out.println("赋值后");
        printArray(array);

        //封装性
        Pack pack = new Pack();
        System.out.println("=============");
        System.out.println("初始化态");
        System.out.println(pack.getName());
        System.out.println(pack.getAge());

        System.out.println("=============");
        System.out.println("赋值后状态");
        pack.setName("ysc");
        pack.setAge(100);
        System.out.println(pack.getName());
        System.out.println(pack.getAge());

    }

    public static void printArray(int[][] array){
        //增强型for循环练习
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

在这里插入图片描述
继承
继承的本质是对某一批类的抽象，从而实现对象是世界的更好的建模。
extends的意思是扩展，子类是父类的扩展。
Java中的类只有单继承，没有多继承。
继承类和类之间是一种关系，除此之外，类和类之间的关系还有依赖，组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示。
子类和父类之间从意义上讲有“is a”的关系。

object类
super
方法重写

package com.ysc.oop;

public class Person {
    //父类
    public String name = "father";
    public int money = 1_0000_0000;

    public Person(){
        this.name = "little_father_init_Student();";
        System.out.println("Person()");
    }
    //默认构造
    public Person(String name){
        this.name = "father_init";
    }


    public void print(){
        System.out.println("father print()");

    }
}

package com.ysc.oop;

public class Student extends Person {
    //子类
    public String name;
    //super指的是父类的构造函数名
    //如果父类定义了有参构造函数，那么父类必须定义显性默认构造函数后，子类才能使用自己的显性默认构造函数
    public Student(){

        super("haha");
        this.name = "little_son_init_Student();";
        System.out.println("Student()");
    }
    public Student(String name){
        this.name = "little_son_init_Student(String);";
        System.out.println("Student(String()");

    }

    public void print(){
        System.out.println(super.name);
        System.out.println(this.name);
        System.out.println("son print()");
        super.print();
    }
}

package com.ysc;

import com.ysc.oop.Student;

public class TestApplication {
    public static void main(String[] args) {
        Student student = new Student("son1");
        student.print();
    }
}

在这里插入图片描述
super注意点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法
Vs this：
代表的对象不同：
this:本身调用者这个对象
super：只能在继承条件才可以使用
构造方法：
this()；本类的构造
super()；父类的构造

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

方法名必须相同。
参数列表必须相同。
修饰符：范围可以扩大：
public>protected>Default>private
抛出的异常：范围，可以被缩小，但不能扩大：ClassNOtFoundException—>exception(大)
重写，子类的方法和父类要一致；

为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足！
2.alt + insert：override

package com.ysc.oop;

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

package com.ysc.oop;

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

    //}

    @Override   //注解：有功能的注释！ 重写 alt+insert
    public void test() {
        System.out.println("A-test()");
    }
}

package com.ysc;

import com.ysc.oop.A;
import com.ysc.oop.B;

public class TestApplication {
    public static void main(String[] args) {
        //静态方法和非静态方法区别很大！

        //静态方法：方法的调用只和左边定义的的数据类型有关
        //非静态静态方法：重写只和非静态方法有关，且为public修饰
        A a = new A();
        a.test();

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

在这里插入图片描述
多态

yangsc6

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础语法学习整理

基础语法1.HelloWorldpublic class HelloWorld { public static void main(String[] args) { //输出一个Hello world！ System.out.println("Hello world!"); }}2.数据类型扩展public class Demo02 { public static void main(String[] args) { //整
复制链接

扫一扫