Java基础学习（7）

Java基础学习

• 一、面向对象进阶版
• • 1.1 静态变量static
  • 1.2 static 内存图
  • 1.3 static的注意事项
  • 1.4 重新认识main方法
  • 1.5 封装
  • 1.6 继承
  • 1.7 继承的特点
  • 1.8 子类继承父类哪些内容
  • • 继承的内存图
  • 1.9 继承中成员变量的访问特点
  • 1.10 成员方法的访问特点
  • • 方法重写
  • 1.11 构造方法的访问特点
  • 1.12 this、super使用总结
• 二、集合
• • 2.1 集合概念特点
  • 2.2 集合与数组的区别
  • 2.3 ArrayList成员方法
  • 2.4 基本数据类型对应的包装类
• 三、多态
• • 3.1 什么是多态
  • 3.2 多态调用成员的特点
  • • 多态调用成员的内存图解
  • 3.3 多态的优势与弊端
  • • 多态的优势
    • 多态的弊端
• 四、包和final
• • 4.1 包
  • 4.2 final关键字
  • • 常量
    • 权限修饰符
• 五、代码块
• • 5.1 代码块分类
  • • 5.1.1

一、面向对象进阶版

1.1 静态变量static

被static修饰的成员变量，叫做静态变量

特点：被该类所有对象共享

static 	teacher;

调用方式：1. 类名调用 2. 对象名调用

//类名调用
StudentTeacher.teacher="Mr.s";

//对象名调用
StudentTeacher s1 = new StudentTeacher();
s1.teacher = "Mr.s"

1.2 static 内存图

静态变量是随着类的加载而加载的，优先于对象出现的

被static修饰的成员方法，叫做静态方法

• 多用在测试类和工具类
• Javabean类中很少会用
• • 调用方式:
    1.类名调用(推荐)
    2.对象名调用

1.3 static的注意事项

• 静态方法只能访问静态变量和静态方法
• 非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
• 静态方法中是没有this关键字

总结: 静态方法中，只能访问静态非静态方法可以访问所有。静态方法中没有this关键字

1.4 重新认识main方法

public: 被JVM调用，访问权限足够大
static: 被JVM调用，不用创建对象，直接类名访问因为main方法是静态的，所以测试类中其他方法也需要是静态的。
void :被JVM调用，不需要给JVM返回值
main:一个通用的名称，虽然不是关键字，但是被JVM识别
String[] args: 以前用于接收键盘录入数据的，现在没用

1.5 封装

对象代表什么，就得封装对应的数据，并提供数据对应的行为

1.6 继承

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系。

public class Student extends Person {}

student称为子类(派生类)，Person称为父类(基类或超类)

**好处：**1. 可以把多个子类中重复的代码抽取到父类中了，提高代码的复用性。
2. 子类可以在父类的基础上，增加其他的功能，使子类更强大

我们什么时候利用继承：

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

1.7 继承的特点

Java只支持单继承，不支持多继承，但支持多层继承

1. 多层继承:子类A继承父类 B，父类B 可以继承父类C

2. 每一个类都直接或者间接的继承于Object
3. Java中所有的类都直接或者间接继承于object类。

1.8 子类继承父类哪些内容

1. 父类的构造方法不能被子类继承

继承的内存图

在继承的过程当中上一个父代都会得到上上一个父代所传下来的 虚方法表这个方法表在每一代的继承下都会得到更新

虚方法表：

就是在父代中容易被调用方的方法或变量，但是这个所加入虚方法表的内容不能是private static final所修饰的

所以我们在调用间接夫方法的时候就可以直接调用：

public class caishuziGram {
    public static void main(String[]args){
    	a.方法c();
    }
}

但是在调用c方法的时，c属于虚方法中

1.9 继承中成员变量的访问特点

就近原则:谁离我近，我就用谁

先在局部位置找，本类成员位置找，父类成员位置找，逐级往上。

public class Fu{
	String name = "fulei";
}

public class zi extends fu{
	String name = "ziwaibu";
	public void ziShow(){
		String name = "zi";
		//当调用时	
		System.out.printIn(name);//打印出来的是“zi”
		System.out.printIn(this.name);//打印出来的是“ziwaibu”
		System.out.printIn(super.name);//打印出来的是“fulei”
	}
}

1.10 成员方法的访问特点

• 直接调用满足就近原则:谁离我近，我就用谁
• super调用，直接访问父类

方法重写

运用场景：

当父类的方法不能满足子类现在的需求时，需要进行方法重写

书写格式：

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法

@Override重写注解：

• 1.@Override是放在重写后的方法上，校验子类重写时语法是否正确。
• 2.加上注解后如果有红色波浪线，表示语法错误。
• 3.建议重写方法都加@Override注解，代码安全，优雅!

重写时就会把之前的值进行覆盖

重写时注意事项：

• 重写方法的名称、形参列表必须与父类中的一致。
• 子类重写父类方法时，访问权限子类必须大于等于父类 (暂时了解:空着不写< protected< public)
• 子类重写父类方法时，返回值类型子类必须小于等于父类
• 建议:重写的方法尽量和父类保持一致。
• 只有被添加到虚方法表中的方法才能被重写

1.11 构造方法的访问特点

• 父类中的构造方法不会被子类继承。
• 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己
  子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。

怎么调用父类构造方法的?

子类构造方法的第一行语句 默认都是super(),不写也存在，且必须在第一行
如果想调用父类有参构造，必须手动写super进行调用

1.12 this、super使用总结

• this:理解为一个变量，表示当前方法调用者的地址值
• super:代表父类存储空间
  

二、集合

2.1 集合概念特点

特点：

可以动态的添加存储空间，只能存储引用数据类型和包装类

表示形式 ： ArrayList<string> = new ArrayList<>();

2.2 集合与数组的区别

• 长度 数组长度固定 集合长度可变
• 存储类型

1. 数组：可以存基本数据类型 、 可以存引用数据类型
2. 集合： 可以存引用数据类型 、 基本数据类型–>包装类

2.3 ArrayList成员方法

import java.util.ArrayList;

public class text {
    public static void main(String[] args) {
        //1.创建一个集合
        ArrayList<String> list = new ArrayList<>();

        //2. 添加元素
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");

        //3. 删除元素
        list.remove("aaa");

        //4. 修改元素
        list.set(1,"ccc");

        //5. 查询元素
        list.get(0);

    }
}

2.4 基本数据类型对应的包装类

import java.util.ArrayList;

public class text {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        
        list.add(1111111);
        list.add(22222);
        list.add(333333);
        
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i) == list.get(list.size()-1)){
                System.out.print(list.get(i));
            }else {
                System.out.print(list.get(i) + ", ");
            }
        }
        System.out.print("]");
    }
}

三、多态

3.1 什么是多态

同类型的对象，表现出的不同形态

多态的表现形式:

父类类型 对象名称 = 子类对象

多态的前提：

• 有继承关系有父类
• 引用指向子类对象
• 有方法重写

Fu zi = new zi();

多态的好处：使用父类型作为参数，可以接收所有子类对象体现多态的扩展性与便利。

3.2 多态调用成员的特点

• 变量调用:编译看左边，运行也看左边
  Javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
java运行代码的时候，实际获取的就是左边父类中成员变量的值
• 方法调用:编译看左边，运行看右边
  编译看左边: javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
运行看右边: java运行代码的时候，实际上运行的是子类中的方法。

多态调用成员的内存图解

3.3 多态的优势与弊端

多态的优势

1 .在多态形式下，右边对象可以实现解耦合，便于扩展和维护

Person p = new student ();
p.work(); // 业务逻辑发生改变时，后续代码无需修改

2. 定义方法的时候，使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利。

多态的弊端

1. 在调用成员方法的时候，不能调用子类特有的方法
   原因：当调用成员方法的时候，编译看左边，运行看右边那么在编译的时候会先检查左边的父类中有没有这个方法，如果没有直接报错

解决方案：

变回子类类型（强制转换），主要转换的时候不能乱转化，对应的子类转化，如果不是对应的子类就会报错

Animal a = new Dog();
Dog d = (Dog) a ;
d.show();//这样才能调用Dog中特有的方法

再上诉的强制转换的条件下有弊端，可以通过以下代码修改

//先判断a是否为Dog类型，如果是就转换为Dog,那么就转换为DOg类型，转换过后变量名为 d
//如果不是，就不转，直接返回false

if(a instanceof Dog d){
	d.lookHome;
}

四、包和final

4.1 包

定义：即文件夹

包名规则：需要全部英文小写，见名知意公司域名反写 +包的作用

使用其他类的规则：

• 使用同一个包中的类时，不需要导包使用
• java.lang包中的类时，不需要导包
• 其他情况都需要导包
• 如果同时使用两个包中的同名类，需要用全类名

4.2 final关键字

最终的--> 不能够被改变

1. 表明该方法是最终方法，不能被重写
2. 表明该类是最终类，不能被继承
3. 变量叫做常量，只能被赋值一次

常量

实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性常量的命名规范:

• 单个单词:全部大写
• 多个单词:全部大写，单词之间用下划线隔开

细节：

• final修饰的变量是基本类型:那么变量存储的数据值不能发生改变

final int age = 10;
age = 15;//报错

• final修饰的变量是引用类型: 那么变量存储的地址值不能发生改变，对象内部的可以改变

Student s = new Student("zhaosi",23);
//记录的地址值不能发生改变，内部属性可以发生改变
// s = new Student();  error;
s.setAge(25);
s.setName("wangwu");
System.out.printf(s);//wangwu 25

常量记录的数据是不可变的

权限修饰符

• 权限修饰符:是用来控制一个成员能够被访问的范围的
• 可以修饰成员变量，方法，构造方法，内部类

权限修饰符的分类：
有四种作用范围由小到大 ( private < 空着不写 < protected < public

权限修饰符的使用规则

实际开发中，一般只用private和public

• 变量私有
• 方法公开
  特例:如果方法中的代码是抽取其他方法*性代码，这个方法一般也私有

五、代码块

5.1 代码块分类

• 局部代码块
• 构造代码块
• 静态代码块

5.1.1