当前位置：首页 > news >正文

java项目总结2

news 来源：原创 2024/9/21 7:08:59

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);//trueSystem.out.println(object instanceof Person);//trueSystem.out.println(object instanceof Object);//trueSystem.out.println(object instanceof Teacher);//falseSystem.out.println(object instanceof String);//falsePerson person = new Student();System.out.println(person instanceof Student);//trueSystem.out.println(person instanceof Person);//trueSystem.out.println(person instanceof Object);//trueSystem.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{@Overridepublic 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);}
}

结果如下：