Java面向对象学习笔记-2

拼搏现实的明天。 2023-10-08 18:02 13阅读 0赞

## 访问修饰符的权限 ##

### 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 ###