三、JAVA基础（个人向）

JAVA基础（个人向）

1.static 关键字

1)static随着类的加载而加载
2)优先于对象存在,肯定不能this共存
3)能够被多个对象共用,共享
4)它的特殊访问方式:
通过类名.变量名---->类变量(变量被static修饰的)
通过类名.方法名()—>类方法(方法被static修饰)

2.继承

• 将多个类的共性内容抽取到一个独立的类中,让这多个类和独立的类之间产生一种关系

2.1特点

1)在Java语言中,类与类之间的关系,只支持单继承,不支持多继承!
2)可以支持多层继承!

2.2 格式

class Fu{
//将一些功能抽取到父类中
}
class Zi extends Fu{
}

2.3 优点

1)可以提高代码复用性
2)提高的代码的维护下
3)类与类之间产生的关系:是多态的前提条件!

2.4 子类和父类的成员变量名称一致下访问方式

1)先在子类的局部位置中找,是否存在这个变量名称,如果存在,就使用;
2)如果不存在,那么就在子类的成员位置中找是否存在,如果存在,就使用
3)如果不存在,那么在父类的成员位置中找是否存在,如果存在,就使用
4)如果不存在,那么久报错了,那说明没有这个变量

2.5 继承中构造方法的访问

• 子类的所有的构造方法的第一句话:super(); 默认的

• 子类的所有构造方法间接访问父类的无参构造方法:
  需要让父类先进行初始化,因为子类中可能会用到父类的数据!(分层初始化)!

• 那么如果父类中没有无参构造方法,子类会怎样?如何解决
  方式1:可以通过手动给出无参构造方法
  方式2:子类的所有构造方法的第一句话: 通过super(xxx):访问父类的有参构造方法
  方式3:在子类的有参构造方法中的第一句话:this():来先访问本类的无参构造方法,然后再本类无参构造方法 第一话
  super(xxx):访问父类的有参构造方法,让父类进行初始化!

2.6 应用场景

如果A类是B类的一种,或者B类是A类的一种,这个使用extends完成两者继续关系,体现的是一种"is a"的关系

2.7 静态代码块,构造方法,构造代码块的优先级

静态代码块 > 构造代码块 > 构造方法

2.8 this和super

• this:代表当前类对象的地址值引用
• super:代表的父类的空间标识(代表父类对象的地址值引用)

访问成员变量,成员方法,构造方法

• 成员变量:
  this.变量名; 它的访问的是本类的成员变量
  super.变量名; 访问父类的成员变量

• 成员方法:
  this.方法名() ;访问本类的成员方法
  super.方法名() ;访问父类的成员方法

• 构造方法:
  this() ;访问的是本类的无参构造方法
  super() ;访问的是父类的无参构造方法

  this(具体值) ;访问的是本类的有参构造方法
  super(具体值);访问的是父类的有参构造方法

3.final关键字

3.1 概念

final是状态修饰符,最终的,无法更改的

3.2 特点

可以修饰类,该类不能被继承
可以修饰成员方法,该方法不能被重写
可以修饰变量,此时变量是一个常量

一般情况:定义常量
public static final 数据类型 变量名 = 初始化;

3.3 final修饰基本数据类型和引用数据类型的区别

• 可以修饰基本数据类型:(普通方式: final int a = xx;),基本数据类型对应的值不能再赋值了;
• 可以修饰引用数据类型: final 修饰实例变量,该对象的地址值不能在改变了

4.方法重写与方法重载

4.1 方法重载Overload

• 在一个类中,定义多个方法,这些方法的方法名相同,参数列表不同,与返回值无关;

• 参数列表:
  1)数据类型不同
  2)参数个数不同
  3)先后顺序

• 重载的目的:为了提高功能的扩展性:同一个方法可以接收很多类型的参数

4.2 方法重写Override

• 在继承关系中,子类出现了和父类一模一样的方法,这个子类将父类的功能覆盖(复写/重写),创建子类具体对象,
• 直接方法该功能,使用的子类的功能!
• 重写的目的:为了沿用父类的功能,并且还需要使用子类的功能(具体的子类才具备具体的动作…)
• 实际开发中: 有的时候需要将api提供一些功能进行重写,完成我们自己的业务需求!
• 后期使用:Servlet(server applet:针对服务端程序开发 :前后端的交互) JavaEE核心技术之一

5.多态

5.1 多态的概念

一个事物在不同时刻体现的不同形态

5.2 前提条件

1)必须继承关系
2)必须存在方法重写
3)必须父类引用指向子类对象

5.3 成员访问特点

1)成员变量:编译看左,运行看左
2)成员方法:(非静态):编译看左,运行看右,(存在方法重写)
3)静态的方法:不算方法重写,跟类相关(编译看左,运行看左)
4)构造方法:分层初始化(先父类,在子类)

5.4 多态的向上转型和向下转型

• 多态的向上转型:多态的第三个前提条件—>父类引用指向子类对象
  格式:Fu fu = new Zi() ;
• 多态的弊端:不能访问子类的特有功能
  可以使用向下转型:
  将父类的强转强转转换为子类引用
  格式:Zi zi = (Zi)fu;

5.5 优势

提高代码的复用性—继承来保证
提高代码的扩展性—多态保证

6.抽象类

6.1 概念

将一些共性内容抽取到独立的类中,并且有些功能仅仅给出声明,不具体实现,具体的实现通过子类进行实现,当前这个方法就是抽象方法

6.2 成员特点

• 成员变量:可以是变量,也可以是常量!
• 成员方法:即可是抽象方法,必须携带abstract关键字,也可以是非抽象方法
• 构造方法:存在无参/有参构造方法----对数据进行初始化

6.3 实例化

• 抽象类的最大特点:不能实例化,不能new ,只能通过子类进行实例化
• 抽象的父类指向子类对象—>抽象类多态 :Fu fu = new Zi() ; (Fu类是抽象类)
• 抽象类的子类如果为抽象类,那么一定会存在最具体的子类,否则不能实例化了

7 接口

7.1 其与抽象类的区别

• 成员的区别
  抽象类:
  成员变量:既可以是变量,也可以是常量
  成员方法:可以存在抽象方法(必须携带abstract关键字),也可以有非抽象方法
  构造方法:存在无参/有参构造方法,—目的需要给数据进行初始化,分层初始化
  接口:
  成员变量:只能是常量,存在默认的修饰符public static final修饰
  成员方法:只能是抽象方法:存在默认的修饰符 public abstract
  构造方法:没有

• 关系的区别
  类与类之间: 继承关系,只支持单继承,不支持多继承,但是可以多层继承
  类与接口: 实现关系,一个类继承另一个类的同时可以实现多个接口,中间逗号隔开
  接口与接口: 继承关系,可以支持单继承,也可以支持多继承,多层继承…

• 设计理念
  抽象类:----->强制子类必须完成的事情,由于存在继承关系,体现的是一种"is a"的关系!
  接口-------->体现某个事物额外的功能,谁实现该接口就具备该功能,体现的是一种"like a"的关系!

7.2 abstract冲突问题

其与final,static,private等关键字都有冲突

8.冒泡排序和选择排序

8.1冒泡排序核心代码

for(int x = 0 ; x <arr.length-1 ; x ++){
    for(int y = 0 ; y < arr.length-1-x ; y++){
        //判断
		if(arr[y] > arr[y+1]){
            int temp = arr[y] ;
            arr[y] = arr[y+1] ;
            arr[y+1] = temp ;
        }
    }
}

8.2 选择排序核心代码

for(int x = 0 ; x < arr.length-1; x ++){
    for(int y = x + 1;  y< arr.length ; y ++){
        //判断
        if(arr[y] < arr[x]){
            int temp = arr[x] ;
            arr[x] = arr[y] ;
            arr[y] = temp ;
        }
    }
    
}