Java面向对象学习笔记-3

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

## final修饰符 ##

> 使用的位置：  
> 类声明中使用：当前类不能被**继承**  
> 变量的声明中使用：将变量变成一个**常量**  
> 方法声明中使用：当前方法不能被**重写**

### 当final修饰符修饰成员变量时初始化问题 ###

可以在构造器以及构造代码块中对成员常量进行初始化

public class A{
        
       final String name;
       //构造器
       public A(){
        
          this.name = "XX";
       }
       //构造代码块
       {
        
          this.name = "xxx";
       }
    }

## static修饰符 ##

> 使用的位置：  
> 成员变量上：  
> （1）同一个类的所有对象共享一个数据，  
> （2）可以使用类名.属性名访问  
> （3）注意：局部变量不能使用static修饰  
> 方法声明中使用：  
> （1）同一个类的所有对象只拥有一个方法的实际实现（被static修饰的方法不能被重写）  
> （2）可以使用类名.方法名()访问  
> TODO：

### static 修饰的方法中只能访问被static修饰的成员变量或成员方法 ###

> 原因：被static修饰的方法和属性加载时机优先于创建对象（优先于对象存在）

### static 修饰的方法中不能使用this\\super关键字 ###

> 原因：类变量、类方法是脱离对象存在的（优先于对象存在）

### 想要实现static方法的重载，必须也被static修饰 ###

> 原因：保证调用的方法一致，只是参数类型不同

### final static 修饰成员变量 ###

> 同一个类的所有对象只有唯一的值共享（配置固定数值的时候使用）

### final static 修饰方法 ###

> 当前方法不能重写且能用类名.方法名（）调用

## 类内部的成员-代码块 ##

### 静态代码块和构造代码块的执行顺序 ###

//对象初始化过程：
        //1. 成员变量初始化默认值
        //2. 静态代码块执行
        //3. 构造代码块执行
        //4. 构造器执行
        
        类当中的成员定义顺序也要按照这个顺序编写

### 构造代码块（非静态代码块） ###

写法

public class A{
        
    
       {
        //构造代码块
          
       }
    
    }

> 执行顺序：  
> 多个构造代码块之间，按照定义顺序从上往下执行  
> 能写的东西：  
> （1）操作静态、非静态成员变量  
> （2）调用静态、非静态成员方法  
> （3）可以对final成员常量初始化赋值  
> 不能写的东西：  
> （1）this调用构造器，super调用父类构造器不能写  
> （2）不能写返回值语句

### 静态代码块（类代码块） ###

写法

public class A{
        
    
       static{
        //静态代码块
          
       }
    
    }

> 执行顺序：  
> 多个静态代码块之间，按照定义顺序从上往下执行  
> 能写的东西：  
> （1）只能操作静态成员变量  
> （2）只能调用静态成员方法  
> （3）可以对final成员常量初始化赋值（保证是静态的就可以）  
> 不能写的东西：  
> （1）this调用构造器，super调用父类构造器不能写  
> （2）不能写返回值语句  
> （3）不能出现调用当前对象的属性和方法（不能使用this语句）

## 内部类 ##

> 根据定义的位置分为：  
> 成员内部类：定义在方法外，类内部  
> 局部内部类：定义在代码块内部的内部类

### 成员内部类 ###

> 可以使用的修饰符：访问修饰符、非访问修饰符：static final

#### 1. 非静态成员内部类 ####

public class User{
        
    
    	public  class A{
        //成员内部类
    
           public String name = "123";
    
           public void aa(){
        
               System.out.println(name);
           }
    
        }
    
    }

对象创建方法：

//1. 创建外部类对象
    Person p1 = new Person();
    
    //2. 外部类对象.new 内部类构造器()
    Person.A a = p1.new A();

内部类访问外部类属性:

public class User{
        
    
    	private String name = "123";
    	
    	 public  class A{
        
    
           public void aa(){
        
               System.out.println(name);
               //不能使用this访问外部类属性，this代表的是内部类对象
           }
    
        }
    
    }

#### 2. 静态成员内部类 ####

public class User{
        
    
    	public static  class A{
        //成员内部类
    
           public String name = "123";
    
           public void aa(){
        
               System.out.println(name);
           }
    
        }
    
    }

对象创建方法：

//1. 创建外部类对象
    Person p1 = new Person();
    
    //2. new 外部类名.内部类构造器()
    Person.A a = new Person.A();

## 匿名类 ##

（1）零时实现接口、抽象类调用

public interface InterA1 {
        
    
        void say();
    
    }
    
    
    //仅限于零时实现，测试 匿名类
            InterA1 aa= new InterA1(){
        
    
                @Override
                public void say() {
        
                    System.out.println("!!!!!");
                }
            };
    
            aa.say();

## 面向对象的特性 ##

### 封装与隐藏 ###

> 封装：借助包结构、类定义、方法定义、内部类定义区分代码内容  
> 隐藏：借助访问修饰符划分访问权限，继承中子类对父类属性、方法的访问  
> 重点：访问修饰符、package、import、类的组成、内部类的定义

### 继承 ###

> 继承： 存在子父关系的类和对象，有实现关系的接口和实现类  
> 作用：帮助我们设计类的时候采用更容易理解的方法去设计类与类之间的关系  
> 重点：抽象类、接口、extends、implement关键字用法、super\\this关键字

### 多态 ###

> 重点：向上转型、向下转型（方法参数、返回值、数组类型定义中的用法）、重写、重载、参数传递

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