Java面向对象学习笔记-2访问修饰符的权限重载（overLoad）和重写（overRide）final 关键字抽象类接口抽象类和接口的区别多态super关键字super和this的对比

访问修饰符的权限

public

范围：本类内部、同包、不同包

protected

范围：本类内部、同包、子类（和包结构无关，子类可能和父类不同包也能访问）

default

范围：本类内部、同包

private

范围：本类内部

重载（overLoad）和重写（overRide）

重载（overLoad）— 找不同（参数列表不同），找相同（方法名相同）

1.位置：出现的位置是同一个类内部的不同方法
2.判定规则
（1）方法名必须相同
（2）参数列表必须不同
（3）和访问修饰符无关
（4）和返回值类型无关
3.使用规则：同一个方法功能，不同参数实现时

public int aa(){}
private void aa(int a1){}

重写（overRide）

1.位置：出现在继承链路中的子父类中（不在同一个类中）
2.判定规则：
（1）方法名必须相同
（2）参数列表必须相同
（3）访问修饰符可以不相同，但是子类重写的方法访问修饰符不能比父类更严格（小）
（3.1）子类和父类在同一个包中：子类能重写父类被：public、protected、(default)
（3.2）子类和父类不在同一个包中：子类能重写父类被：public、protected
（4）和返回值类型有关
（5）父类方法被final 修饰，子类无法重写（无法重写）
（6）父类方法被private修饰的，子类无法重写（访问不到）
（7）父类方法被static修饰时，子类无法重写（不允许重写类方法）
3.使用规则：多态情景下的多功能调用

final 关键字

变量上使用-final关键字

作用：把变量定义为常量
定义位置：成员变量可以定义、局部变量也可以定义

方法上使用-final关键字

作用：当继承情况下，当前方法不能被重写

在类上使用-final关键字

作用：在类声明中定义了final关键字，代表当前类不能被继承
例子:String

抽象类

什么是抽象类？
代码定义上：类声明中使用了abstract修饰的类以及包含抽象方法的类叫抽象类
作用上：父亲没完成的事情让儿子完成（父类为抽象类，目的是为了让子类继承，同时实现父类定义的抽象方法）
与普通类的区别：就是可以定义抽象方法而已，不能创建对象（不能实例）

抽象类的定义

//抽象类的声明（不能使用final修饰，因为抽象类必须给子类继承）
public abstract class  AbstractFather{

	//抽象方法的定义（抽象方法不能被：private、final修饰）
   abstract void aa();

	//抽象类是可以定义普通方法的
	public void bb(){
	    int i = 1;
	}
	
	//抽象类也可以定义属性，但是不能被abstract修饰（属性不能被重写）
	String name;
	
	//抽象类也可以定义构造器（作用：提供给子类实例化时调用，会在对象的实例化章节讲）
	public AbstractFather(){
        System.out.println("父类构造器调用！");
    }
    public AbstractFather(int a){

    }

}

接口

接口的定义

1.接口没有构造器，也就无法实例化

接口类

public interface 接口名称{

}

接口的组成

成员变量（是成员类常量，默认 public static final修饰的变量）

public interface A{

    String name = "123";//等同于public static final String name = "123";

}

成员方法

(1) 公共的抽象方法(默认被public abstract修饰的方法)

public interface A{

    void aa();
    //等同于
    public abstract void aa();

}

(2) 被static修饰的方法-可以写方法体

//只能被public修饰 接口名.bb()
    public static void bb(){
        System.out.println("ccccc");
    }

（3）被default修饰符修饰的方法-可以写方法体

//只能被public修饰, 提供给子类调用或重写 JDK1.7之后的新特性
    public default void bb2(){
        System.out.println("bb2()");
    }

接口的实现

(1) 实现接口

public class 普通类名 implements 接口名1,接口名2...{
    //必须重写所有接口中定义的抽象方法，如果不实现完成，就会变成抽象类
}

（2）边继承、边实现

public class 普通类名 extends 抽象类名或普通类名 implements 接口名1,接口名2...{
    //必须重写所有接口、抽象类中定义的抽象方法，如果不实现完成，就会变成抽象类
}

接口的多继承

一个接口类可以同时继承多个接口
接口只能继承接口，不能是普通类和抽象类

public interface 接口 extends 接口名称1,接口名2... {
   //会把别的接口中的抽象方法继承到当前接口中
}

抽象类和接口的区别

区别点 抽象类 接口
定义 包含一个抽象方法的类| 抽象方法和全局常量的集合+2（static、default修饰的方法可以写实现）
组成 构造方法、抽象方法、普通方法、常量、变量| 常量、抽象方法、被static和defult修饰的方法
使用 子类继承抽象类(extends) | 子类实现接口(implements)
关系 抽象类可以实现多个接口 | 接口不能继承抽象类，但允许继承多个接口
常见设计模式 模板设计 | 工厂设计、代理设计
对象 都通过对象的多态性产生实例化对象
局限 抽象类有单继承的局限 | 接口没有此局限
实际 作为一个模板 | 是作为一个标准或是表示一种能力
选择 如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限
特殊 一个抽象类中可以包含多个接口，一个接口中可以包含多个抽象类

多态

什么是多态？（广义多态）
同一个行为，具有多个不同表现形式或形态的能力

Java中的多态
若编译时类型和运行时类型不一致，就出现多态

父类类型 a1 = new 子类类型（）;

多态的必要前提

1. 必须有继承：继承普通类、抽象类、以及实现接口
2. 方法要出现重写（父类和子类的同一个行为有不同的表现）
3. 代码写法上：父类类型 a1 = new 子类类型（）;

多态的优点

1. 可以消除对象之间的耦合、代码耦合
2. 可以具有替换性
3. 可扩充性
4. 接口性
5. 灵活性高
6. 简化性

多态定义的理解

(1)抽象类

public abstract class AbClass1 {

    public abstract void abSay();

}

（2）接口类

public interface InterA1 {

    void say();

}

（3）普通类

public class NormalClass1 {

    public void normalSay(){
        System.out.println("NormalClass1-normalSay()");
    }

}

（4）继承类（可以继承也可以实现）

public class TestSon extends NormalClass1{//可以继承也可以实现

    @Override
    public void normalSay() {
        System.out.println("TestSon-normalSay()");
    }
}

（5）多态调用

public static void main(String[] args) {

        //子类对象赋值给父类引用类型，完成多态对象的定义方法
        NormalClass1 o = new TestSon();

    }

多态的使用场景（支付案例）

引用转型

1. 向上转型

//祖宗类>爷爷类>父类>子类
        //祖宗类 a1 = new 父类();  向上转型
        NormalClass1 s1 = new TestSon();

2.向下转型

//祖宗类>爷爷类>父类>子类
        //祖宗类 a1 = new 父类();  向上转型
        NormalClass1 s1 = new TestSon();
        
        //祖宗类 = （父类）子类
        //强制类型转换符只要能够让目标对象类型兼容

        //子类 = 父类
        //一定要确定强制类型转换符号中类型是否匹配
        TestSon s2 = (TestSon)s1; //向下转型
        
        //错误案例1：类型不匹配
        String s3 = (String)s1;//编译错误 真实类型是TestSon类型 不是String
        
        //错误案例2：
        TestSon s3 = (TestSon)new NormalClass1();
        

instanceof 操作符

boolean aa = 要判断的对象 instanceof 判断类型的类名;

x instanceof A
判断机制：

1. 判断x对象是否是A类类型以及A的子类类型，如果是返回true，不是false
2. x对象的真实类型一定要和A类有继承或实现关系，否则代码编译报错

NormalClass1 ss = new TestSon();

//正确写法
boolean aa= ss instanceof TestSon;
//错误
boolean aa= ss instanceof String;//string和ss对象类型不存在继承或实现

虚拟调用规则

什么虚拟调用？
多态对象的描述下，调用方法指向过程是在内存中动态绑定的。

1. 引用类型是父类，只能访问父类定义的方法和属性

2.如果在多态调用中非要使用子类特有的属性和方法，只能向下转型

//Father>WscSon
        Father f = new WscSon();

        //访问属性值只和引用类型相关
        System.out.println(f.age);//属性不具备多态性质   属性不能被重写

        f.say();//实际执行的是子类方法实现 虚拟调用
        
        //如果在多态调用中非要使用子类特有的属性和方法，只能向下转型
        WscSon s2 = (WscSon)f;
        s2.run();//转型之后才能访问到特有的属性和方法
        s2.code;

super关键字

作用：调用父类或超类（最父类）的属性或方法、构造器
含义：父类对象的内存空间引用地址
super关键字可以追溯父类，调用的可以是所有父类中的属性和方法

//在子类方法或代码块中
super.方法名()
super.属性名;

super关键字调用构造器

调用规则：

1. super调用构造器只能调用直接父类的构造器
2. super(),构造器中调用直接父类的无参构造器是默认行为
3. 如果构造器中编写了调用父类的有参构造行为，则默认行为被覆盖

调用的顺序：
构造器调用从最父类往子类顺序调用

super调用构造器和this调用构造器不能同时出现,而且要在构造器代码的第一行

当父类定义了有参构造没有定义无参构造器时，子类构造器必须指定一个父类构造器调用

super和this的对比

this

访问属性：可以访问当前对象的所有属性（包含继承的属性，注意访问修饰符）
访问方法：可以访问当前对象的所有方法（包含继承的方法，注意重写方法的调用，注意访问修饰符）
访问构造器：调用本类构造器，且代码必须在构造器的第一行
this的意义：代表的是当前对象的引用

super

访问属性：可以访问父类到超类的所有属性（注意访问修饰符）
访问方法：可以访问父类到超类的所有方法（注意访问修饰符）
访问构造器：调用直接父类的构造器，super()是默认行为，代码必须在构造器第一行
super的意义：代表的是父类内存地址

感谢各位看官，如果喜欢的话点赞给我多多支持，我会一直出Java全栈开发课程内容，蟹蟹大家~磕头

最后

以上就是深情钢笔为你收集整理的Java面向对象学习笔记-2访问修饰符的权限重载（overLoad）和重写（overRide）final 关键字抽象类接口抽象类和接口的区别多态super关键字super和this的对比的全部内容，希望文章能够帮你解决Java面向对象学习笔记-2访问修饰符的权限重载（overLoad）和重写（overRide）final 关键字抽象类接口抽象类和接口的区别多态super关键字super和this的对比所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。