java项目总结2

代码的奴隶（艾伦·耶格尔）

已于 2024-07-05 09:27:29 修改

阅读量659

点赞数 20

文章标签： java 开发语言

于 2024-07-03 23:58:49 首次发布

本文链接：https://blog.csdn.net/2302_80364740/article/details/140143307

版权

3.了解Java的内存分配

4.重载

定义：在一个类中，有相同名的，但是却是不同参数（返回类型可以不一样）

重载的优点：

1.减少定义方法时使用的单词

2.减少调用方法时候的麻烦（比如sum的返回两个数的和，这两个数可以为int，也可以为double）

具体请看如下：

5.集合

导包import Java.util.ArryList;

import java.util.ArrayList;
import java.util.Scanner;
import java.util.StringJoiner;
public class Main {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("A");  //
        list.add("B");
        list.add("B");
        list.add("C");
        //删除（按内容删除）
        boolean res1= list.remove("A");
        System.out.println(res1);
        
        //集合中没有R，所以无法删除
        boolean res2= list.remove("R");
        System.out.println(res2);
        System.out.println(list);
        
//删除（搜引删除）
String str= list.remove(1);
System.out.println(str);
        System.out.println(list);

        //修改
String result=list.set(1,"Dd");
System.out.println(result);
        System.out.println(list);

        //查询
        String s=list.get(1);
        System.out.println(s);

        //长度
System.out.println(list.size());
System.out.println(list);
    }
}

结果如下：

static表示静态，是Java的一个修饰符，可以修饰成员方法，成员变量。

注意:1.静态方法中只能访问静态变量和静态方法。

2.非静态可以访问所有。

3.静态方法中没有this关键字

静态函数中无this，只能使用静态变量，非静态中含有this，可以使用静态函数及变量。

修饰成员变量：

修饰成员方法：

主函数：

6.继承

继承的优点：

1.可以把多个子类中的重复代码抽取到父类中，提高了代码的复用性。

2.子类可以在父类的基础上，增加其它的功能，使子类更加强大。

什么时候使用继承？

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码。

继承关系如下：注意：私有的成员变量虽然被继承下来了，但是却不能用。

虚方表：非private,非static，非final修饰

例子如下：

this指子类，super指父类！

如果有父类函数fun，但是子类需要功能的函数与之不同，则可以在子类中进行重写。

注意：

1.重写方法，名称一样，行参列表必须与父类一致。

2.子类重写父类方法时，访问权限必须大于等于父类（暂时了解：空着不写<protected<public）

3.子类重写父类方法时，返回值类型必须小于等于父类。

4.建议：子类重写的方法尽量与父类一致。

5.只有被添到虚方表中的方法才能被重写。

2.及修饰词

3.及指类型，子类小于父类，父类等于父类正确（Animal是父类，Dog是子类，及为返回值小于父亲）

7.多态

1.什么是多态

对象的多种形态。

2.多态的前提

1.有继承/实现关系

2.有父类引用指向子类对象

3.有方法的重写

public class Demo01 {
    public static void main(String[] args) {
        /*
        一个对象的实际引用类型是确定的，比如：
        new Student()
        new Person()
         */

        Student s1 = new Student();//子类指向的引用
        
        //子类能调用的方法都是自己的或者是父类的
         
        //父类的引用可以指向子类（有父子关系就可以 ，比如用String肯定不行，因为没有指定的关系。）

        Person s2 = new Student();//父类指向的引用
        
        //父类型虽然可以指向子类，但是不能调用子类独有的方法
         
        Object s3 = new Student();
 
        s2.run();//运行结果为run，因为子类重写了父类的方法，执行的为子类的方法
        s1.run();
        s1.eat();
        //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大。
        /*
        ((Student)s2).eat();
        强制转换后可以进行调用
         */
        (s2.eat());//无法调用是因为 Person s2 = new Student();虽然new了Student()但不能使用Student()方法，要看Person里面有没有，有的话才能用。
        // 子类重写了父类的方法，执行的为子类的方法。子类和父类的方法都有的话，子类没有重写方法，就调用父类的，如果重写的话就带哦用子类的。
    }
}
 

public class Person extends Object {   //在这里Person为子类，Object为父类
    public void run(){
        System.out.println("run");
    }
}
public class Student extends Person{   //在这里Student为子类，Person为父类
    @Override        //提示重写方法
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

3.多态的好处

1.使用父态作为参数，可以接受所有子类对象

2.体现多态的便利与扩展性

注意：

调用成员方法的特点：编译看左边，运行看右边

调用成员变量的特点：编译看左边，运行看左边

4.多态的弊端

假设Animal a=new Dog（）；（Animal为父类，Dog为子类，Cat也为子类）

不能调用子类的特有功能，编译的时候会检查左边的父类中有没有这个方法，如果没有则直接报错。

解决方案：将其变回子类。（Dog d=(Dog) a）强制转换，也可以如下：

拓展：instanceof关键字

作用：instanceof关键字可以判断两个类之间是否存在父子关系。

1.父类引用指向子类的对象。

2.子类转换为父类（向上转型），不用强制转换。

3.父类转换为子类（向下转型），强制转换后会丢失方法。

4.方便方法的调用，减少重复的代码，提升代码的利用率并且使代码变得更简洁。

以上图为例，判断a是否为Dog类型，是则强制转换成Dog并用d表示。

网上示例：

public class Demo01 {
    public static void main(String[] args) {
        //Object>String
        //Object>Person>Student
        //Object>Person>Teacher
        //System.out.println(A instanceof B);
        //A和B是否有继承关系
        Object object = new Student();
        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(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);//编译错误
    }
}
 
public class Person extends Object {
    public void run(){
        System.out.println("run");
    }
}
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

8.StringBulider

StringBulider是一个java里的关键字，可以看做一个容器，但是其是一个可以改变的容器，对其有四种操作可以进行，分别是添加元素（append），反转元素（reverse），获取长度（length）以及将StringBulider容器里面的东西变成字符串（toString）

作用：提高字符操作效率

public class Main {
    public static void main(String[] args) {
        StringBuilder b=new StringBuilder();
        b.append("yyz").append(18).append("nb").append("yyds");
        //这是其中的特殊处理方法，类似一条龙服务
        System.out.println(b);

        //字符串的反转
        b.reverse();
        System.out.println(b);

        //获取字符串长度
        int len=b.length();
        System.out.println(len);

        //将容器里面的东西赋给字符串
        String s= b.toString();
        System.out.println(s);
    }
}

结果如下：

9.StringJoiner

也可以看做一种容器，创建之后里面的内容是可变的。注意：需要导包

import java.util.StringJoiner;
public class Main {

    public static void main(String[] args) {
        StringJoiner a = new StringJoiner(",");
        a.add("111").add("222").add("333");
        int len1 = a.length();
        System.out.println(len1);
        System.out.println(a);
        String str1 = a.toString(); //转化成字符串形式
        System.out.println(str1);

//中间，前面，最后（，【，】，这三个的放置位置）
        StringJoiner b = new StringJoiner(",", "[", "]");
        b.add("abc").add("bcd").add("ert");
        int len2 = b.length();
        System.out.println(len2);
        System.out.println(b);
        String str2 = b.toString();
        System.out.println(str2);
    }
}

结果如下：

拓展之调整字符串内容

1.用subString进行截取，然后拼接

2.将字符串变为字符数组，调整完了，在把字符数组变为字符串

String str1=str2.subString(0,2);(截取0到2的字符串)

String str1=str2.subString(2);(截取2以后的字符串)

10.包和final

包:

它是Java中组织和管理代码的重要方式，它提供了命名空间管理、访问控制和代码组织等功能，有助于提高代码的可维护性和可重用性。

使用其他类的规则：

1.使用同一个包中的类不需要导包。

2.使用Java.lang包中的类时，不需要导包。

3.其他情况都需要导包。

4.如果同时使用两个包中的同名类，需要用全类名。

包的声明：在Java源文件中，包的声明应该放在文件的开头，使用 package 关键字进行声明，例如：

package com.example.mypackage;

public class MyClass {
    // 类定义
}

导入其他包：如果需要在一个Java文件中使用其他包中的类，可以使用 import 关键字将这些类导入，例如：

import java.util.ArrayList;
import java.util.List;

public class MyMainClass {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // 使用 ArrayList 和 List 类
    }
}

final:

final 是一个关键字，它可以用来修饰类、方法和变量，具有不同的含义和用途：

1.final 修饰类：当一个类被声明为 final 时，表示这个类是最终类，不能被继承。即子类无法扩展（extend）这个类。例如：

final class FinalClass {
    // 类定义
}

2.final 修饰方法:当一个方法被声明为 final 时，表示这个方法是最终方法，子类不能重写（override）这个方法。例如：

class Parent {
    public final void finalMethod() {
        // 方法定义
    }
}

3.final 修饰变量:当一个变量被声明为 final 时，表示这个变量的值只能被赋值一次。一旦赋值后，就不能再修改。对于基本数据类型，这意味着它的值不可变；对于引用类型，意味着引用不可变，但是对象的状态可以改变。例如：

public class FinalExample {
    public static final int MAX_COUNT = 100;
    final String name;

    public FinalExample(String name) {
        this.name = name; // 可以在构造函数中为 final 变量赋值一次
    }

    public void modifyName() {
        // 编译错误！final 变量 name 已经被赋值过，不能再次赋值
        // this.name = "New Name";
    }
}