Java学习笔记6

目录

继承

特点

继承就是子类继承父类的特征和行为，是的子类对象具有父类的实例域和方法，或子类从父类集成方法，使得子类具有父类相同的型为
class 子类 extends 父类
Java中只有单继承，多重继承。没有多继承，但是有多实现

创建子类对象时，会先创建父类对象

public class Demo {
     public static void main(String[] args) {
          Student s = new Student();
     }
}
class Person {
     {
          System.out.println("父类对象被创建了");
     }
}
class Student extends Person {
     {
          System.out.println("子类对象被创建了");
     }
}

输出结果为

父类对象被创建了
子类对象被创建了

除了public和protected修饰的属性或者方法，子类才能调用

super关键字

调用super的构造方法的代码，必须放在第一行，所以有super出现时，不能出现this关键字

重写

重写的规则

1. 参数列表必须完全与重写方法相同
2. 返回值类型必须完全与重写方法的返回值类型相同
3. 访问权限不能比父类中被重写的访问权限更低
4. 父类的成员方法只能被他的子类重写
5. 声明为static和private的方法不能重写，但是能被再次声明

重写和重载的区别

重写 Override：子类重写父类的方法
重载 Overload：方法名相同，参数列表不同

1. 重载发生在同一个类中，重写发生在子父类中
2. 重载的参数列表必须不同，重写的参数列表必须相同
3. 重载返回值类型可以不同，重写的返回值类型必须相同
4. 重载与访问权限无关，重写的子的访问权限必须不能小于父的访问权限
5. 重载在与异常无关，重写异常范围可以更小，但是不能抛出新的异常

final关键字

1. 用于修饰属性，变量—>变量变成了常量，无法再次对其赋值，如果final修饰的时成员属性，必须在声明时对其赋值，如果final修饰的时局部变量，只能赋值一次
2. 用于修饰类------------>最终类不可以被继承的类
3. 用于修饰方法---------->不能被子类重写

全局常量：public static final

抽象类

抽象类常见问题

1. 抽象类不能直接创建对象
2. 抽象类不能使用final声明，final声明的类不能被继承
3. 抽象类是否有构造方法
   1. 能有构造方法，而且子类对象实例化的时候的流程和普通类的继承时一样的，都要先调用父类中的构造方法，之后再调用子类自己的构造方法

抽象类和普通类的区别

1. 抽象类必须用public或protected修饰
2. 抽象类不能使用new关键字创建对象，但是在子类创建对象的时候，抽象父类也会被JVM实例化
3. 如果一个子类继承抽象类，那么必须实现所有的抽象方法，如果有为实现的抽象方法，那么子类也必须定义为抽象abstract类

接口

如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义为一个接口

定义格式

interface 接口名称{
    全局常量
    抽象方法
}

使用

接口使用时是通过实现implements关键字使用
接口不同于继承，接口可以多实现

面向接口编程思想

接口是定义（规范，约束）与实现（名实分离的原则）的分离

1. 降低程序的耦合性
2. 易于程序的扩展
3. 有利于程序的维护
   先写接口，定义好约束，再根据约束进行相关功能的实现

接口的继承

接口因为都是抽象部分，不存在具体的实现，所以允许多继承

注意！！

如果一个接口想要使用，必须依赖子类
子类如果不是抽象类的话，要实现接口中的所有抽象方法

抽象类和接口的区别

1. 抽象类要被子类继承，接口要被类实现
2. 接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法
3. 接口里定义的变量只能是公共的静态的常量，抽象类中定义的变量是普通的变量
4. 抽象类使用继承来使用，无法多继承，接口使用实现来使用，可以多实现
5. 抽象类中可以包含static方法，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）
6. 接口不能有构造方法，但是抽象类可以有

多态

概念

对象的多种表现形式
方法的重写和重载也是多态的一种表现，只不过是方法的多态

多态的使用

对象的类型转换
子类实例转为父类实例----->向上转型------>父类引用指向子类对象
父类实例转为子类实例----->向下转型

instanceof关键字

判断某个对象是否是指定类的实例
格式

实例化对象   instanceof  类   //返回的是boolean类型的数据

Object类

概念

Object类是所有对象的父类，是顶级父类，如果一个类没有明确继承某一个具体的类，则默认继承Object类

Object类的多态

使用Object可以接收任意类型的数据

如何使用API

鼠标按住CTRL然后单击鼠标，即可查看源码

toString()

返回对象的字符串的表现形式
表现方式为：类型 @ 16进制的哈希码

equals（）和==的区别

equals：某个对象是否等于此对象
==：比较内存地址值是否相等

equals方法重写的5个特性

1. 自反性：对于任何非空的参考值x，x.equals(x)应返回true 自己跟自己比应返回true
2. 对称性：对于任何非空引用之x和y，x.equals(y)应返回true 当且仅当y.equals(x)返回true
3. 传递性：对于任何非空引用x，y和z，如果x.equals(y)返回true y.equals(z)返回true 那么 x.equals(z)也应返回true
4. 一致性：对于任何非空引用x和y，多次调用x.equals(y)始终返回true或者始终返回false，前提是未修改比较信息
5. 非空性：对于任何非空引用x，x.equals(null)应该返回false

内部类

将一个类定义在另一个类或者一个方法中
一般包括

1. 成员内部类
2. 局部内部类（执行体里面定义的内部类）
3. 匿名内部类（只能用一次）
4. 静态内部类

成员内部类

特点

成员内部类可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法是，会发生隐藏现象，默认情况下访问的是成员内部类的成员，如果要访问外部类的同名成员，需要以下面的形式访问

外部类.this.成员变量
外部类.this.成员方法

举个栗子：

public class Test{
	class Info{
		public void say() {
			System.out.println("内部类的say方法");
			//调用外部类的同名say方法
			Test.this.say();
		}
	}
	public void say() {
			System.out.println("外部类的say方法");
	}
}
public class Demo{
	public static void main(String[] args){
		Test test = new Test();
		Info info = test.new Info();
		info.say();
	}
}

输出结果：

内部类的say方法
外部类的say方法

局部内部类

定义在方法或者一个作用域里的类，和成员内部类的区别在于 局部内部类的访问权限 仅限于方法内部或者该作用域内
局部内部类就像是方法里的局部变量一样，是不能由public，protected，private以及static修饰的

匿名内部类

只能使用一次的内部类

创建格式

父类类型  对象名称 = new 父类构造器 (参数列表)|实现接口{

};

静态内部类

静态内部类不需要依赖外部类对象，和静态成员属性有点类似，并且不能使用外部类的非static成员变量或者方法
举个栗子：

public class Test{
	static class Info{
		System.out.println("这是静态内部类");
	}
}
public class Demo{
	public static void main(String[] args){
		Test.Info info = new Test.Info();
		info.say();
	}
}

输出结果：

这是静态内部类

包装类

一切皆对象

Java提供了八种基本数据类型的包装类

序号	基本数据类型	包装类
1	int	Integer
2	char	Character
3	float	Float
4	double	Double
5	boolean	Boolean
6	byte	Byte
7	short	Short
8	long	Long

以上的八种基本数据类型的包装类，可以将基本数据类型按照类的形式进行操作
但是，这八种包装类也是分为两种类型的

1. Number：Integer、Short、Long、Double、Float、Byte都是Number的子类，表示的是一个数字
2. Object：Character、Boolean都是Object的直接子类

装箱和拆箱

将一个基本数据类型变为包装类，称为装箱操作
将一个包装类变为基本数据类型，称为拆箱操作

手动拆箱和手动装箱

1. 在Java1.5以前，直接使用各个包装类的构造方法进行装箱
   举个栗子：

int a = 10;
Integer b = new Integer(a);

2. 在Java1.5以前,手动拆箱
   举个栗子：

Integer b = 20;
int a = b.intValue();

自动拆箱和自动装箱

在Java1.5开始，提供了自动拆箱和自动装箱操作
举个例子

Integer a = 10;//自动装箱
int b = a;//自动拆箱

可变参数

一个方法中定义完了参数，则在调用时必须传入语气一一对应的参数，在jdk1.5以后，提供了可以根据需要自动传入任意个数的参数

返回值类型  方法名称  (数据类型··· 参数名称){
	在方法内部以数组接收
}

！！可变参数只能出现在参数列表的最后！！

递归

在方法的定义中使用方法自身，也就是说，递归算法是一种直接或者间接调用自己的算法
举个栗子：利用递归求阶乘

举个例子

Integer a = 10;//自动装箱
int b = a;//自动拆箱

# 可变参数
一个方法中定义完了参数，则在调用时必须传入语气一一对应的参数，在jdk1.5以后，提供了可以根据需要自动传入任意个数的参数

返回值类型 方法名称 (数据类型··· 参数名称){
在方法内部以数组接收
}

！！**可变参数只能出现在参数列表的最后**！！
# 递归
在方法的定义中使用方法自身，也就是说，递归算法是一种直接或者间接调用自己的算法
举个栗子：利用递归求阶乘