Java基础-第4天-CSDN博客

本文链接：https://blog.csdn.net/weixin_43862020/article/details/115692063

Java基础-第4天

1.StringBuilder

StringBuilder是一个可变字符串类，可以把它看做是一个容器。这里指的可变，指的是StringBuilder对象中的内容是可变的。
String中的内容是不可变的，字符串的拼接是将两个字符串并入一个常量池中，开辟新的内存空间，再用变量名指向这个内存空间的。

StringBuilder有多种构造方法：
第一种 StringBuilder sb = new StringBuilder("abx");
第二种 StringBuilder sb = new StringBuilder();//输出空白字符串
添加和反转方法：
StringBuilder sb2 = sb.append("hello");
sb2和sb是同一个对象，所以直接用sb.append("hello")也行。
sb.reverse();
String→StringBuilder：
StringBuilder sb = new StringBuilder("abx");
StringBuilder→String：
StringBuilder sb = new StringBuilder("abx");
String s = sb.toString();

2.ArrayList

ArrayList的长度是可以随时变化的集合。底层是数组。

ArrayList的方法：
    public static void main(String[] args) {
        ArrayList<String> ab = new ArrayList<>();
        ab.add("hello");
        ab.add("aaa");
        ab.add(2,"dnaslkdj");
        System.out.println(ab.remove("aaa"));//ArrayList的删除方法，返回值为boolean，即若存在参数元素，则返回true，反之则返回false
        System.out.println(ab.remove(1));//ArrayList的删除方法，返回值为删除的元素，注意和第一个区分开。
        System.out.println(ab.set(1,"aaa"));//设置函数，超过索引会发生索引越界错误。
        System.out.println(ab.get(1));//取值函数，超过索引会发生索引越界错误。
        System.out.println(ab.size());//取ArrayList的长度。
    }

3.继承

继承是面向对象的三大特征之一，可以继承父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

格式：
public class 子类名 extends 父类名｛
类的内容...
｝
父类也被称为基类和超类；子类也被称为派生类。

继承的好处：

提高了代码的复用性；
提高了代码的维护性，如果方法的代码需要修改，修改一处即可。

继承的弊端：

继承让类与类之间产生了关系，当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性。

继承中变量的访问特点：

调用一个变量时，系统会先从本方法里面找，若没有，就会到子类属性找，若没有，则到父类里面找，以此类推。

super和this关键字

在这里插入图片描述

继承中构造方法访问特征

子类中的构造方法默认都会访问父类中的无参构造方法。
原因：

子类会继承父类中的数据，可能还会使用父类的数据。所以子类初始化之前，一定要先完成父类数据的初始化。
每一个子类构造方法的第一条语句都是super()

继承中成员变量和方法的访问特征

不能被继承的父类成员

private成员属性/方法；
子类和父类不在同包，使用默认访问权限的成员；
构造方法。
访问修饰符使用范围总结：

继承的注意事项

Java类只支持单继承，不支持多继承。
Java类支持多重继承。

4.方法重写

子类中出现了和父类中一模一样的方法声明，但是功能主体子类有自己特有的内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

新建手机类
Phone
public class Phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}
新建新手机类
NewPhone

public class NewPhone extends Phone{
    @Override
    public void call(String name) {
        System.out.println("开启视频功能");
        super.call(name);
    }
}
新建测试类
PhoneDemo
public class PhoneDemo {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.call("牛皮");
        NewPhone newPhone = new NewPhone();
        newPhone.call("牛皮");
    }
}
运行结果：
给牛皮打电话
开启视频功能
给牛皮打电话

子类重写了父类的方法，注解为Override.。
重写父类方法的几个注意事项：

私有方法不能被重写。
子类方法访问权限不能更低（public>默认>私有）。

5.重载和重写的区别

方法的重载和重写都是实现多态的方式。重载发生在同一个类中，同名方法可以有不同的参数列表（包括参数类型的不同，参数个数不同和返回类型的不同）；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法的参数列表一样，子类比父类被重写方法拥有更高的访问权限，不能比父类方法声明更多的异常。重载对返回类型没有特殊的要求。（借鉴老哥帖子https://blog.csdn.net/wintershii/article/details/80558739）

6.import和final

关于import ，当在用到其他包中的类时在包声明行后面形如：import XX.XX.XX；
关于’final’：

当一个方法被final修饰时，子类不可以被重写，但是可以被继承；
如果一个类被final修饰，不能被继承；
如果一个成员变量被final修饰，不能被重新赋值。
final修饰局部变量时分为两种情况，如下：

建立Student类
public class Student {
    public int  age = 20;
}
main函数
public class Main {
    public static void main(String[] args) {
        final int age = 20;
        age = 100;//修饰基本数据类型，不能重新赋值，报错
        System.out.println(age);
        final Student student = new Student();
        Student s = new Student();
        student.age = 100;//student是引用类型的变量，所以内容可以变（当student类中变量也没有被final修饰，若有修饰，被修饰的成员变量和方法仍然根据前三条规则来），但是地址值不能变
        student = s;//地址不能变，报错
        System.out.println(student.age);
    }
}

7.Static修饰符

Static修饰的方法叫类方法，修饰的变量叫类变量，被类的所有对象都共享。且静态的方法只能访问静态的方法和变量。

新建Phone类
public class Phone {
    public int battery;
    public static String  brand;//类变量
    public Phone(){

    }
}
main函数
public class PhoneDemo {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        Phone p2 = new Phone();
        p1.battery = 3000;
        p2.battery = 4000;
        Phone.brand = "IPHONE";//经常这样调用通过类名调用
        System.out.println(p1.battery);
        System.out.println(p2.battery);
        System.out.println(p1.brand);//也可以通过对象名调用
        System.out.println(p2.brand);
    }
}

8.多态

三个条件下会才会有多态的概念：

有继承/实现关系；
有方法重写；
有父类引用指向子类对象。

多态综述

新建Animal类
public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("动物吃东西");
    }
}
新建Cat类
public class Cat extends Animal {
    public  int age = 20;
    public int weight = 10;
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}
新建测试类
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();//多态
        System.out.println(a.age);
        System.out.println(a.weight);//报错，说明在多态中，对于成员变量来说，编译看Animal也就是左边，执行也看父类的成员变量（运行结果为40而不是20），报错就说明系统去父类中找这个类但是没有找到。
        a.eat();//父类和子类中都有这个方法，执行结果为“猫吃鱼”，所以执行看子类，也就是右边。
        a.playGame();//报错，说明在多态中，对于方法来说，编译也看Animal，编译看左边。
    }
}
总结：
对于成员变量来说，编译看左边，执行看左边。
对于成员方法来说，编译看左边，执行看右边。
这是因为成员方法是重写过来的，执行顺序是由下往上的。