java学习

开始学习java啦（悲）

java语法

1.1java的运行方式

Java编译器将准备好的源文件编译成了class文件，真正被执行的应该是class文件。此时将class文件放入到类加载器，放在Jvm中进行。字节码校验器来进行代码的校验，校验完成若没有了错误，此时的解释器便开始工作将我们的程序解释给操作系统从而进行解读.

1.2第一个java程序

1
2
3
4
5
6
7
public class hello {
    public static void main(String[] args){
        System.out.print("hello\n");
        System.out.println("20");
        System.out.println("3.21");
    }
}

在这里需要建立一个java文件名为hello.java和public class 后面的hello相同

1.3数据类型

img

1.4数据强制转换

byte，short，char-》int-》long-》float-》double

代码需要进行处理不能够自动的完成转换。

格式：（范围小的类型）+范围小的变量名=（范围小的类型）+原本范围大的数据

比如int a=100l会报错，因为不能string转换为int

需要使用如下的写法

1
2
3
4
5
int a=(int) 100a;
byte a =(byte) 200;
System.out.println(a);
//输出是-56
//发生了内存溢出

2.1 print和println的区别

  • print命令不会在末尾添加换行符，会将输出内容连续打印在同一行上。
  • println命令会在末尾添加换行符，将每个输出内容放在一个新的行上。

2.2常量和变量

使用final 常量=值

包括

（1）字符串常量：凡是用双引号引起来的量：如“ABC” “Hellow” “123”

（2）整数常量：无小数点的数字：如1 -100 0

（3）浮点型：直接写上的数字，有小数点：如2.5 -3.14 0.0

（4）字符常量：凡是用单引号引起来的单个字符：如‘A’ ‘b’ ‘1’ ‘中’

（5）布尔常量：只有量中取值：如 true false

（6）空常量：null 代表没有任何的数组

使用变量

数据类型+变量名=值

2.3变量的作用域

1.类变量

static的关键字+变量类别+变量名称

随着类的出现而出现

2.实例变量

写在类的里面，方法的外面

通过这个类才能使用

3.局部变量

写在方法里面的变量，必须初始化和声明值

以下为实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class hello {
    static long ctf=114514;//类变量
    int web;//实例变量
    int study;
    public static void main(String[] args){
     int name1= (int) 100l;局部变量
     System.out.println(name1);//直接输出局部变量
    hello hello=new hello();//定义一个对象
    hello.web=(int)1919810;//给实例变量赋值=>对象.变量名字
    hello.study=996;
    System.out.println(hello.web);//调用同赋值
    System.out.println(ctf);//直接输出类变量
    add hc=new add();
    System.out.println(hc.yhh);
    }
}
class add {
    int yhh=114;//实例变量
}

3.1运算符

算数运算符号

/ * - + %(mod)

赋值运算符

=，+=，-=，*=，/=

和c语言类似，但是只有变量才能使用赋值运算符号

关系运算符

<,>,<=,=>,==,!=

结果是一个bool型的结果，只有true和false

逻辑运算符号

&&与，||或，！非

（含义同数电..害…..数电）

&&和||有短路的特点，

&&左边为false时不计算右边，||左边为true是不计算右边

（突然想起select 1 and 0 and 1，果然语言都是相同的）

3.2自增自减

++，–，同c

3.3 ++a和a++

区别同c语言里面的++a和a++

4.1scanner

使用之前需要引入对应的类sacnner类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    import java.util.*;//导入库
public class hello {
    public static void main(String[] args){
    Scanner scanner = new Scanner(System.in);
        //创建一个scanner对象
    String src = scanner.nextLine();
        /*读取其中的数据 next不能得到有空格的字符串
        空格之后的数据会被默认忽略
        nextline()可以读取直到回车位置的数据
        类似于scanf()*/
    System.out.println("here is the input data "+src);
    scanner.close();
        //关闭刚刚开启的io流
}
}

class add {
    int yhh=114;

}

4.2判断接下来有无输入

1
2
3
4
if(scanner.hasNext()){
       src=scanner.nextLine();
       System.out.println("hood "+src); 
   }

4.3流程控制

Java是顺序执行的结构

4.4不同的输入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner;

public class ReadDifferentDataTypes {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入一个布尔值：");
        boolean bool = scanner.nextBoolean();
        System.out.println("你输入的布尔值是：" + bool);
        
        System.out.print("请输入一个整数：");
        int num = scanner.nextInt();
        System.out.println("你输入的整数是：" + num);
        
        System.out.print("请输入一个字符串：");
        String str = scanner.next();
        System.out.println("你输入的字符串是：" + str);
        
        scanner.close();
    }
}

5.1if选择语句

if(关系表达式<或者是布尔表达式>){
语句体（true就成立执行语句体，false就绕过了语句体，直接输出结束。）；
}

if的分支选择和扩展同c语言

这里不在赘述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.util.Scanner;

import javax.swing.plaf.synth.SynthEditorPaneUI;
public class hello {
    public static void main(String[] args){
    Scanner scanner = new Scanner(System.in);
    int src = scanner.next();
    if(src>=60){
        System.out.println(src+" you pass this test");
    }else{
        System.out.println(src+"sorry you fail");
    }
    scanner.close();
    }
}

5.2switch输入

同c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void main (String[] args){
    char grade = 'c';
    //switch匹配一个值比较方便
    switch (grade){
        case 'a':
        System.out.println("优");
        break;
        case 'b':
            System.out.println("良");
            break;
        //break在整个语句中，一旦被执行将会结束整个循环。
        //如果不加break将会出现贯穿的现象。
        //c和d如果不加break将会打印输出“中”后面的所有的输出字符。
        case 'c':
            System.out.println("中");
            break;
        case 'd':
            System.out.println("差");
            break;
        //default的作用是在case匹配失败之后才会被执行，打印出来相对应的输出信息。
        default:
            System.out.println("您的输入有误！");
    }
}

5.3循环

循环也类似与c语言，这里不多说

6.1方法的调用和定义

定义方法是

1
2
3
4
修饰符+返回值的类型+方法名字（参数类型，此参数名）
{
方法  return 返回值
}

在同一个类之下可以直接调用

在不同的类下需要先使用类的名字和方法然后再调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Scanner;

import javax.swing.plaf.synth.SynthEditorPaneUI;
public class hello {
    public static void main(String[] args){
    Scanner scanner = new Scanner(System.in);
    for(int i=1;i<=5;i++){
        int src = scanner.nextInt();
    a.cheak(src);
   // scnner.close();
    }
    scanner.close();}
}
class a{
public static int cheak(int src){
    if(src>=60){
        System.out.println(src+" you pass this test");
    }else{
        System.out.println(src+"sorry you fail");
    }
    return 0;
}

}

6.2修饰符区别

public：表示该成员是公共的，可以被任何其他类访问。

static：表示该成员是静态的，属于类而不是类的实例。静态成员被所有类的实例共享，可以通过类名直接访问，无需创建类的实例。

final：表示该成员是不可变的，一旦被定义赋值后就不能再更改。final修饰的变量不能被重新赋值，final修饰的方法不能被重写，final修饰的类不能被继承。

区别：

  • public和static都是访问修饰符，用于限制成员的访问范围，而final是一个修饰符，用于声明不可变的成员。
  • public用于声明该成员对所有类可见，static用于声明该成员属于类而不是实例，final用于声明该成员不可更改。
  • public可以用于类、方法和成员变量，static可以用于方法和成员变量，final可以用于类、方法和成员变量。

综上所述，public和static都用于修饰访问权限和属于类的成员，而final用于声明不可变的成员。

6.3方法的重载

要求

1.方法名字必须要求一样，但是参数名不一样，类型不一样，派列方式不一样

2.如果只是方法的返回值不一样不能完成方法的重载

程序运行的时候汇通过参数去匹配对应的方法然后执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class a{
public static int cheak(int src){
    if(src>=60){
        System.out.println(src+" you pass this test");
    }else{
        System.out.println(src+"sorry you fail");
    }
    return 0;
}
public static int cheak(int src,int a){
    if(src>=a){
        System.out.println(src+" you pass this test");
    }else{
        System.out.println(src+"sorry you fail");
    }
    return 0;
}
}

在这里存在的不同类里面，根据check函数的不同参数去匹配最终执行的方法

7.1数组

基础定义类似c语言

创建的方法

数据类型[]数组名字=new 数据类型[]{数据元素}

1
int[] arry1=new int[]{10,20,30,40,50}
1
2
3
4
5
6
7
8
9
10
public static void main (String[] args) {
      //直接创建一个数组，里面全是int数字，
      int[] arr1 = new int[]{10,20,30,40,50};
      int[] arr2 = {10,20,30,40,50};
      //拆分写
      int[] arr3;
      arr3=new int[4];
      int[] arr4;
      arr4= new int[]{10,20,30,40,50};
  }

静态数组指定内容

动态数组指定了长度

数组的建立都会有初始化的过程，为数组中每一个位置赋一个初始值的大小

7.2数组的遍历

同c语言

8.1对象和类定义

对象指：抽象的具体实体

类：抽象的具体类型，对一类事务进行系统的描述，但是不代表具体的某一是事物

8.2类的创建/调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;//1导入包名称，类名称
public class hello {
    public static void main(String[] args){
    scanner abc=new Scanner(System.in);/*
    创建一个新的对象
    类对象 对象名 =new 对象类名称()  */
    abc.hasNext()//成员方法   对象.变量()
     //调用成员属性使用 对象名字.成员变量，名字}   
}
    //定义一个标准类
    /*（1） 所有的成员变量都用private修饰、
（2） 每个成员变量都有getxxx()detxxx()方法
（3） 有一个无参构造
（4） 有一个全参构造*/
    //这里定义一个类（不标准）
    class a {
    String b;
    int c;
    static boolean d(int c) {
        return (c >= 100);
    }
}

关于 static

静态变量（static variable）是属于类的变量，而非具体实例对象的变量。它的特点是所有对象共享同一个变量副本，当一个对象对该变量进行修改后，其他所有对象访问到的都是已经进行过修改的值。

静态方法（static method）是属于类的方法，而非具体实例对象的方法。它可以直接通过类名调用，不需要先创建一个对象。静态方法通常用于定义一些通用的工具方法或者用于创建实例对象前的初始化操作。

静态变量是固定的，只能在这个类内部修改，不能再外面被修改

也就是说有如果static了一个变量a

如果new了一个对象d，那么d.a的值对外来说一旦进行修改

这个类的实例对象的a值都会发生变化

相当于这个类里面的全局变量

只要是用这个类实例化的对象都会发生改变

以下为示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class hello {
    public static void main(String[] args){
 a studen=new a();
    studen.c=12;
    System.out.println(a.c);//输出12
a studen2=new a();
System.out.println(studen2.c);//输出12
studen2.c=11;
System.out.println(studen.c);//输出11
        //显然对studen1和studen2的c的改变是一起的，也可以把她当作一个a类内部的全局变量来看

    }
}
class a {
    public static int c;
}

8.3构造器

创建对象的时候需要使用的方法

new的本质就是在掉用构造方法

如果没有构造器，在new的时候，系统会自动构造一个无参数构造器

类似与php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Person {
    private String name;
    private int age;
    public Person() {
        name = "";
        age = 0;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

9.1封装

把一些类里面相关的较为复杂的结构进行隐藏，只留下简单的对外接口

使用pravite修饰类里面的成员

1
2
3
class a {
    private String b="szdasd";}

这些变量不能在外部被进行修改，只能在类内部才能进行修改，在外部不能被修改也不能被调用

想要调用只能间接调用，这里使用两个函数getxxxx和setxxxx

get函数主要是为了访问相关的数据

不能有参数，必须有返回类型且和对应变量的类型一致

1
2
3
4
5
6
class a {
    private String b="szdasd";
public String geta(){
    return this.b;
}}
//想要调用直接a.getn()就可以调用

set函数主要是为了修改相关的值

对于set来说，不能有返回值，参数类型和成员变量对应

1
2
3
4
5
class a {
    private String b="szdasd";
public void setb(String b){
    this.b=b;
}}

9.2继承

继承的本质是

子类实例具有父类的特征和行为，使得子类对象可以具有父类的特征和行为

在java中使用extends关键字可以声明一个类是另一个类继承下来的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//class 子类 extends 父类{}
实例如下
import java.util.Scanner;
public class hello {
    public static void main(String[] args){
        acm acm =new acm();
        ctf ctf=new ctf();
        System.out.println(acm.target);
        System.out.println(acm.name);
        System.out.println(ctf.name);
        System.out.println(ctf.target);
    }
}
class game{
     String target="point";
}
class acm extends game{
    String name="acm is bad";
}
class ctf extends game {
  String name="ctf is good";
}

对于调用函数，子类中有就直接调用，没有相关函数就向上寻找在她的父类里面去寻找相关函数，如果找不到就继续向上进行寻找

子类可以继承所有父类的方法

但是private的私有不能被调用或者继承

9.3this和super

super代表的是在子类里面调用父类的方法或者是属性

1
2
3
4
5
调用父类的构造方法：当子类需要调用父类的构造方法时，可以使用super()来实现。在子类的构造方法中，使用super()调用父类的构造方法，以便完成父类的初始化操作。

调用父类的成员变量和方法：通过super关键字，子类可以访问并使用父类的成员变量和方法。在子类中，如果有与父类同名的成员变量或方法，使用super关键字可以显式地指明要访问父类的成员。

调用父类的方法，并进行方法重写：子类可以使用super关键字来调用父类的方法，并可以在子类中对父类的方法进行重写。通过使用super关键字，子类可以在重写的方法中调用父类的原始实现。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Parent {
    String name;

    Parent(String name) {
        this.name = name;
    }

    void display() {
        System.out.println("Parent class: " + name);
    }
}

class Child extends Parent {
    String name;
    Child(String parentName, String childName) {
        super(parentName); // 调用父类的构造方法
        this.name = childName;
    }
    @Override
    void display() {
        super.display(); // 调用父类的方法
        System.out.println("Child class: " + name);
    }
}
public class Main {
    public static void main(String[] args) {
        Child childObj = new Child("Parent", "Child");
        childObj.display();
    }
}
//在上述示例中，Child类继承了Parent类，子类中使用super(parentName)调用了父类的构造方法。然后，子类重写了父类的display()方法，并通过super.display()调用了父类的实现。输出结果如下

对于this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Person {
    String name;

    Person(String name) {
        this.name = name; // 引用当前对象的成员变量
    }

    void display() {
        System.out.println("Name: " + this.name); // 引用当前对象的成员变量
    }

    void sayHello() {
        System.out.println("Hello, " + this.name + "!"); // 引用当前对象的成员变量
    }
}

public class Main {
    public static void main(String[] args) {
        Person personObj = new Person("Alice");
        personObj.display();
        personObj.sayHello();
    }
}

9.4方法的重写

好乱好乱好乱

1.静态方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class hello {
    public static void main(String[] args){
        b aaa = new b();
        aaa.test();//方法的调用只与定义的数据类型相关
        //这里aaa的数据类型属于b，调用的就b的静态方法输出b=》text
        System.out.println(aaa.aa);
        a bbb = new b();
        bbb.test();
        System.out.println(bbb.aa);
    }
}
class a{
   String aa;
    public a(){
      this.aa="a=>";
      return;
    }
    public static void test(){
System.out.println("a=>text");
    }

}
class b extends a{
    String aa;
    public b(){
        this.aa="b=>";
        return ;}
        public static void test(){
System.out.println("b=>text");
    }
}//a继承了b类，但是对b的test方法进行了重写

一句话，数据类型是谁的，就调用谁的静态方法

对于a aaa=ew b();的解释

在这个过程中，首先会调用类 b 的构造方法，然后类 b 继承了类 a，所以在调用 b 的构造方法之前，也会调用类 a 的构造方法。这是因为构造方法的调用是从最顶层的父类开始逐级向下传递的。

具体的调用顺序是这样的：

  1. 调用类 a 的构造方法：类 a 的构造方法中设置了 aa 成员变量为 “a=>”。
  2. 然后调用类 b 的构造方法：类 b 的构造方法中设置了 aa 成员变量为 “b=>”。

所以，在创建 b 类的实例时，实际上调用了类 a 和类 b 的构造方法，因此 aaa 对象的 aa 成员变量的值将是 “b=>”，这是因为在构造过程中，最后一次赋值覆盖了之前的赋值。

总之，从父类开始一次次调用构造方法

b aaa = new b(); a bbb = new b();

不论前面是啥，都是从父类到子类向下构造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class hello {
    public static void main(String[] args){
        b aaa = new b();
      //  aaa.test();
      System.out.println(aaa.aa);
        a bbb = new b();
        //bbb.test();
       System.out.println(bbb.aa);
    }
}
class a{
   String aa;
    public a(){
     System.out.print("a=>");
        this.aa="aa";
      return;
    }
    public static void test(){
System.out.println("a=>text");
    }

}
class b extends a{
    String aa;
    public b(){
     System.out.println("b=>");
       this.aa="bb";
        return ;}
        public static void test(){
System.out.println("b=>text");
    }
}
/*  a=>b=>
    bb
    a=>b=>
    aa

2.非静态方法的调用

va中的非静态方法重写是通过子类重新定义一个与父类中方法签名（方法名称和参数列表）相同的方法来实现的。以下是非静态方法重写的要点：

  1. 子类中的重写方法必须和父类中被重写的方法具有相同的方法签名，包括方法名称、参数列表以及返回类型。
  2. 重写方法不能使用比父类中被重写方法更严格的访问修饰符。子类可以将父类中的方法从 protected 或者 default 访问级别变更为 public，但不能更严格。
  3. 重写方法不能抛出比父类中被重写方法更宽泛的异常类型。子类方法可以抛出父类方法中抛出异常的子类异常，或者干脆不抛出异常。
  4. 重写方法不能使用 static 或 final 修饰符。static 方法是与类关联的，而非继承关系，而 final 方法无法被子类覆盖。
  5. 重写方法应该使用 @Override 注解来标识，这是一种好的编程实践，可以帮助编译器检查是否正确地进行了重写。

下面是一个示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
javaCopy codeclass Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dog = new Dog();

        animal.makeSound(); // Output: Animal makes a sound
        dog.makeSound();    // Output: Dog barks
    }
}

在这个示例中，Animal 类有一个非静态方法 makeSound()，Dog 类继承了 Animal 类并重写了 makeSound() 方法。在 main 方法中，我们可以看到多态性的效果，调用 dog.makeSound() 时会实际调用 Dog 类中的重写方法。

总之，Java中的非静态方法重写允许子类为继承自父类的方法.

而静态方法无法被重写，而是被隐藏，调用时取决于引用类型。

9.5多态

同一个方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用类型很多。

首先，子类可以继承父类的属性和方法，子类也可以重写父类的方法，也可以重写父类的方法或者父类的属性。

其次，重写是重要的部分，通过在子类对象定义一个相同名称，相同参数，相同返回类型的函数，就会发生方法重写.前提要求是，父类方法必须是可以继承的。

（即使用public、protected或没有访问修饰符）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫发出喵喵的声音");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗发出汪汪的声音");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Cat();
        animal1.makeSound(); // 输出：猫发出喵喵的声音

        Animal animal2 = new Dog();
        animal2.makeSound(); // 输出：狗发出汪汪的声音
    }
}

9.6 instanceof关键字

可以用来判断两个类之间是否存在父子关系

  1.父类引用指向子类的对象。
  2.子类转换为父类（向上转型），不用强制转换。
  3.父类转换为子类（向下转型），强制转换后会丢失方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Woof!");
    }

    void fetch() {
        System.out.println("Fetching the ball");
    }
}

public class Main {
    public static void main(String[] args) {
        // 向上转型
        Animal animal = new Dog(); // 子类对象转换为父类引用
        animal.makeSound(); // 调用的是子类的方法，输出 "Woof!"

        // 向下转型
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal; // 强制类型转换
            dog.makeSound(); // 输出 "Woof!"
            dog.fetch();     // 调用子类特有的方法，输出 "Fetching the ball"
        } else {
            System.out.println("Animal is not a Dog");
        }

        // 向下转型 - 错误的情况
        Animal anotherAnimal = new Animal();
        // 下面的转换会引发 ClassCastException，因为anotherAnimal并不是Dog的实例
        // Dog anotherDog = (Dog) anotherAnimal;

        // 向下转型 - 安全检查
        if (anotherAnimal instanceof Dog) {
            Dog anotherDog = (Dog) anotherAnimal; // 不会执行到这里
        } else {
            System.out.println("Animal is not a Dog");
        }
    }
}

没有向下转型的时候，父类不能调用子类的方法，需要向下转型之后才能调用

而子类可以随意调用父类的方法，比如使用super等方法

9.7status关键字

status是类里面共享的，它类似于全局变量

如果一个类的实例改变了status的值，那么所有这个类的值都会发生变化

类似于都是用指针指向了同一个内存地址，然后修改了这个值之后，所有地址区间上的这个值都变化了，没有加status时，就像结构体一样。是定义了一个变量。

1
2
2.非静态方法可以访问本类中的所有静态方法。
  3.静态方法可以调用本类中所有的静态方法。

静态方法在加载的时候是和main函数一起加载的，所以无法调用

而非静态方法来之后，

可以访问本类的所有方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class MyClass {
    static void staticMethod1() {
        System.out.println("This is a static method 1.");
    }
    
    static void staticMethod2() {
        System.out.println("This is a static method 2.");
    }
    
    void nonStaticMethod1() {
        System.out.println("This is a non-static method 1.");
    }
    
    void nonStaticMethod2() {
        System.out.println("This is a non-static method 2.");
    }
    
    void callingStaticMethods() {
        // 在非静态方法中可以访问本类的所有静态方法
        staticMethod1();
        staticMethod2();
    }
    
    static void callingAllMethods() {
        // 在静态方法中可以调用本类中的所有方法（静态和非静态）
        staticMethod1();
        staticMethod2();
        // nonStaticMethod1(); // 编译错误，非静态方法不能直接从静态方法中调用
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myObj = new MyClass();
        
        myObj.callingStaticMethods(); // 调用非静态方法，间接调用静态方法
        MyClass.callingAllMethods();  // 直接调用静态方法，可以调用其他静态和非静态方法
    }
}

9.8抽象类

抽象类定义;在普通类的结构里面增加抽象方法的组成部分。

抽象方法定义：是指没有方法体的方法

抽象类的主要特点如下：

  1. 无法实例化： 你不能直接创建抽象类的对象，因为抽象类本身是不完整的，它可能包含未实现的抽象方法。只能通过创建继承抽象类的具体子类对象来使用抽象类的功能。
  2. 可以包含抽象方法： 抽象类可以包含抽象方法，这些方法没有具体的实现。子类继承抽象类后，必须提供这些抽象方法的具体实现。抽象方法在抽象类中用于定义方法的签名和输入输出，但不提供实际的代码实现。
  3. 可以包含普通方法： 除了抽象方法外，抽象类也可以包含普通的方法（有具体实现的方法）。这些方法可以在抽象类中提供通用的功能。
  4. 用于继承： 抽象类被设计为供其他类继承的基类。子类继承抽象类后，必须实现其中的所有抽象方法，才能成为一个完整的类。

抽象类通常用于定义一组相关的类的通用行为和属性，而不关注具体的实现。通过在抽象类中定义抽象方法，可以强制子类提供自己的实现，从而达到约定接口和代码复用的目的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
abstract class Shape {
    abstract double calculateArea(); // 抽象方法，不提供实现
}

class Circle extends Shape {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double width;
    double height;

    Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    double calculateArea() {
        return width * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        Rectangle rectangle = new Rectangle(4, 6);

        System.out.println("Circle Area: " + circle.calculateArea());
        System.out.println("Rectangle Area: " + rectangle.calculateArea());
    }
}

9.9接口

使用interface作为接口，是一种特征的约定

有点类似与抽象类、

在这里只包含抽象的方法，并不含有具体的实现方法。在调用的时候需要给出具体的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class hello {
    public static void main(String[] args) {
        B cc = new B();//接口a的类b
        cc.b = "hello";
        cc.out(cc.b);//调用接口A在B类中的方法
    }
}

interface A {
    void out(String a);
   // void in();如果写入这个，在对应的B类里面没有覆写，会报错
}//接口的建立

class B implements A {//实现接口A的B类
    String b;

    @Override
    public void out(String b) {
        System.out.println(b);
    }
}

9.10 内部类

内部类是指 将一个类定义在一个类和一个方法里面

一个java文件里面只能拥有一个public类，但是可以有很多的类

成员内部类

定义在类的内部，内部类可以访问外部类用的属性和方法，但是外部类想要访问成员内部的属性和方法，首先要实例内部化的成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class hello {
    public static void main(String[] args) {
      a out=new a();//先实例化外部类
      System.out.println(out.a);//调用正常的成员
      a.b in=out.new b();//实例化内部类
     System.out.println(in.b);//调用内部类
    }
}
class a{
   String a="这是外部类";
   class b{
    String b="这是内部类";
   }
}

静态内部类

多加了一个static的关键字，内部只能访问外部静态成员的变量和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Hello {
    public static void main(String[] args) {
        a out = new a(); // 实例化外部类
        System.out.println(out.a); // 调用外部类的成员
        // 不需要先创建外部类的实例，直接使用外部类名来引用内部静态类
        a.b.bb();
    }
}
class a {
    String a = "这是外部类";
    static class b {
        static void bb() {
            System.out.println("这是内部静态类");
        }
    }
}

匿名内部类

没有名字的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class AnonymousInnerClassExample {
    interface Greeting {
        void greet();
    }

    public static void main(String[] args) {
        // 使用匿名内部类实现接口
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void greet() {
                System.out.println("Hello from anonymous class!");
            }
        };

        anonymousGreeting.greet(); // 调用匿名内部类的方法
    }
}

局部内部类

仅仅只存在在他所在的代码里面，只能被final修饰

有点像局部变量。

10 异常

关键字：try、catch、final、throw、throws。

  try：抛出异常（尝试着去处理什么东西）。

  catch：捕获异常。

  final：无论有什么异常发生，finally都会被执行（可以运行清理类型等收尾善后性质的语句）。

  throw：当程序发生异常而无法处理的时候，会抛出对应的异常对象。

  throws：throws用来在类中捕获异常信息，标明方法可能抛出的异常。

参考

1.Java入门级基础教学（史上最详细的整合）_java基础入门_代码贩子、的博客-CSDN博客

2.gpt

3.搜索引擎

4，感谢yjp学长教授