1. JAVA三大特性
封装、继承、多态
2.面向对象
2.1 本质
面向对象的本质是:以类的方式组织代码,以对象的方式组织数据。
2.2 构造函数
一旦显示定义了有参构造,则类中的无参构造必须显示定义,不能使用默认的无参构造。
可以使用alt+insert,让IDE自动写构造函数。
3. 继承
JAVA中类只有单继承,没有多继承!
3.1 extends
子类继承父类,使用关键字extends来表示。
快捷键Ctrl + H,会在IDE的右侧显示类的树结构。
在JAVA中,所有的类,都默认直接或间接继承Object类。
3.2 super
注意点:
1.super调用父类的构造函数,且必须放在子类构造方法体的第一个。
2.super必须只能出现在子类的方法或构造方法中。
3.super 和 this 不能同时调用构造方法。因为this和super都要求放在构造方法体的第一个。
super VS this
- 代表的对象不同
this:代表调用者本身
super:代表父类对象的引用
2.前提条件不同:
this:没有继承也可使用
super:只能在继承条件下才可使用
3.构造方法:
this():本类的构造函数
super():父类的构造函数
3. 重写
- 为何需要重写?
父类的功能,子类不一定需要 或者 子类不一定满足! - 重写的条件:
2.1 子类要重写父类的方法,继承是前提;
2.2 子类的方法名必须和父类的方法名相同;
2.3 子类的参数列表必须和父类的参数列表要相同;
2.4 方法的修饰符,子类的修饰符范围可以扩大但不能缩小:public > protected > default > private
2.5 方法抛出的异常,子类范围可以缩小但不能扩大。
重写:子类的方法和父类方法必须要一致,但方法体不同!
** 快捷键:Alt+insert:选择override,IDE可在子类中自动补填重写函数。**
4. 多态
多态的实现,优势在于:在执行时才知道具体执行哪个方法。
注意:多态是方法的多态,属性没有多态性!
4.1 多态实现的三个条件
JAVA中多态的实现同C++中的多态实现:
- 父类的引用 指向 子类对象;
- 子类中的方法 是重写 父类中的方法;
- 父子类间要有继承关系。
4.2 无法实现多态的三种函数
以下方法因为无法实现重写,故而无法实现多态:
- static 方法。static方法属于类,不属于对象实例。
- final修饰的方法,无法被重写。
- private修饰的父类方法,无法被子类调用,无法被重写。
4.3 instanceof
instanceof用来判断某个引用对象 是否 可以指向某个类型的对象。
如下: x instanceof y
若x引用可指向y类型的对象,则返回TRUE,否则返回FALSE。
5. 抽象类
注意点:
- 同C++,Java中的抽象类不能被实例化,即不能new这个抽象类,只能靠子类去实现这个抽象类。
- 抽象类中可以有普通方法,但抽象方法必须在抽象类中,即有抽象方法的类必须用abstract关键字声明为抽象类。
// 抽象类
public abstract class Person {
// 抽象方法:约束,只写一个框架,让子类去实现
// 抽象方法只有函数声明没有函数体
public abstract void doSomething();
public void run() {
}
Person(){
System.out.println("Person Constructor");
}
}
// 子类在继承抽象类时,必须实现该抽象类中的所有的抽象方法,除非该子类也是个抽象类
public class Student extends Person {
Student() {
System.out.println("Student Constructor");
}
@Override
public void doSomething() {
}
public static void main(String[] args) {
Student student = new Student();
}
}
6.接口
普通类:只有具体实现。
抽象类:具体实现 和 规范(抽象方法)都有。
接口:只有规范(抽象方法)。将约束和方法分离,真正的面向接口编程。
面向对象的精髓是对对像的抽象,最能体现这一点的就是接口。24种设计模式之所以只针对具备了抽象能力的语言,如C++、Java、C#等,就是因为设计模式研究的就是如何合理地去抽象。
注意:
1. 接口不能被实例化(接口是别抽象类还要抽象的一种规约),接口中没有构造函数。
2. 关键字implements可实现多个接口,实现伪多继承。
6.1 接口声明
声明类的关键字是class,声明接口的关键字是interface。
// 接口类
/* 1.定义接口的关键字是interface。
* 2.接口定义后一定要有实现类。
* 3.接口中的所有定义的方法都是public abstract的,故在接口中定义方法,不需要写修饰符。
*/
public interface UserService {
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
注意:接口中定义的属性,其修饰符都是public static final,即都是常量,但一般不会在接口中定义属性。
6.2 接口的实现
1.接口必须要有实现类,实现类使用关键字implements实现接口。
2.接口的实现类的命名一般为在接口后加Impl。
3.Java中类只能单继承,但实现类可实现多个接口,故而达到多继承的目的。
4.一个实现类,必须重写其继承的接口中的所有方法。
/* 1.类可以实现接口。使用关键字implements。
* 2.实现了接口的类,必须重写接口中的所有方法。
* 3.接口的实现类,其命名方式为,在接口类后加后缀Impl。
* 4.Java中类只能单继承,但一个类能实现多个接口,从而达到多继承的目的。
*/
public class UserServiceImpl implements UserService, TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
7.内部类
内部类就是在一个类的内部再定义一个类。如在类A中定义一个类B,则B相对于A即为内部类,而A相较于B即为外部类。
在一个类文件中,只能有一个public修饰的类,但能有多个类。
7.1 成员内部类
1.通过外部类对象来实例化内部类。
2.内部类可访问外部类的私有属性及方法。
public class OuterClass {
private int id = 18;
public void out(){
System.out.println("外部类方法");
}
public class InnerClass{
// 成员内部类可获取外部类的私有属性及方法
public void getId(){
System.out.println(id);
}
public void in(){
System.out.println("内部类方法");
}
}
}
public class Application {
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
// 通过外部类对象来实例化内部类
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.getId();
}
}
7.2 静态内部类
静态内部类即在成员内部类的基础上,加上一个static关键字。
静态内部类不能访问外部类中非静态的方法或属性。
public class OuterClass {
private int id = 18;
public static class InnerClass{
public void getId() {
// 静态内部类不能访问外部类中的非静态成员属性或方法
// System.out.println(id);
}
}
}
7.3 局部内部类
public class OuterClass {
private int id = 18;
public void method() {
// 局部内部类
class Inner{
}
}
}