Java菜鸟学习总结Java基础知识（类）

Posted 2020-12-31 featherw

目录

• 【Java菜鸟学习总结】Java基础知识（类）
  • 1、面向对象编程
  • 2、类
  • 3、static关键字
  • 4、final关键字

【Java菜鸟学习总结】Java基础知识（类）

---

1、面向对象编程

1.1、面向对象编程的特征

面向对象编程(OOP)的三大特征 {
    
    封装;
    
    继承;
    
    多态;
}

1.2、类与对象概述

类与对象是面向对象的核心概念。

类与对象 {
    
    类;  // 类是对于一类事物的描述，是抽象的、概念的定义。
    
    对象; // 对象是实际存在的该类事物的每个个体，因而也别称为实例。
}

2、类

2.1、类的语法

修饰符 class 类名 {
    
    属性声明;      // 属性，对应类中的成员变量
    方法声明;      // 行为，对应类中的成员方法
}

2.2、类的关系

类的关系 {
    
    关联关系;
    继承关系;
    聚集;
    组合;
}

2.3、属性

2.3.1、属性的语法

修饰符 类型 属性名 = 初值

2.3.2、Java变量

• Java变量的概念

变量 {
    
    成员变量 {
        实例变量;       // 不以static修饰
        类变量;         // 以static修饰
    }
    
    局部变量 {
        形参;          // 方法签名中定义的变量
        方法局部变量;   // 在方法中定义
        代码块局部变量; // 在代码块中定义
    }
}

• 成员变量和局部变量的区别

成员变量和局部变量的区别 {
    
    成员变量 {
        // 成员变量定义在类中，在整个类中都可以被访问。
        // 成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。
        // 成员变量有默认初始化值。
        // 成员变量的权限修饰符可以根据需要，选择任意一个。
    }
    
    局部变量 {
        // 局部变量只定义在局部范围内，如方法内、代码块内等。
        // 局部变量存在于栈内存中。
        // 作用的范围结束，变量空间会自动释放。
        // 局部变量没有默认初始化值，每次必须显示初始化。
        // 局部变量声明时不指定权限修饰符。
    }
}

2.4、方法

2.4.1、方法的语法

修饰符 返回值类型 方法名 (参数列表) {
    
    方法体语句;
}

// 注意：Java里方法不能独立存在，所有的方法都必须定义在类里。

2.4.2、方法的参数传递

方法的参数传递方式 {
    
    值传递;    // 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响
}

2.4.3、方法的重载

重载 {
    方法名相同;
    参数列表(参数个数、参数类型)不同;
    与返回值类型无关;
}

2.5、构造器

2.5.1、构造器的语法

修饰符 类名 (参数列表) {
    
    初始化语句;
}

// 构造器的作用：创建对象，给对象进行初始化

2.5.2、构造器的特征

构造器的特征 {
    
    // 具有与类相同的名称
    // 不声明返回值类型
    // 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
}

2.5.3、构造器的分类

构造器分类 {
    
    隐式无参构造器;            // 系统默认提供
    
    显示定义一个或多个构造器;   // 无参、有参
}

2.5.4、构造器注意事项

构造器注意事项 {
    
    // Java语言中，每个类都至少有一个构造器
    // 默认构造器的修饰符与所属类的修饰符一致
    // 一个类可以创建多个重载的构造器
    // 父类的构造器不可被子类继承
}

2.6、this

this {
    
    this.a = 10;             // 方法内部使用，即这个方法所属对象的引用
    this.sayHello("hello");  // 方法内部使用，即这个方法所属对象的引用
    
    this();                  /* 构造器内部使用，表示该构造器正在舒适化的对象。
                                使用this()必须放在构造器的首行。
                                使用this调用本类中其他的构造器，保证至少又一个构造器是不用this的。
                             */
}

// 说明：this表示当前对象，可以调用类的属性、方法和构造器

2.7、封装

Java中通过将数据声明为私有的（private），再提供公共的（public）方法：getXxx()和setXxx()实现对该属性的操作。

2.7.1、权限修饰符

• Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限

权限修饰符 {
    
    private;     // 内部类√   同一个包×   子类×   任何地方×
    缺省;        // 内部类√   同一个包√   子类×   任何地方×
    protected;   // 内部类√   同一个包√   子类√   任何地方×
    public;      // 内部类√   同一个包√   子类√   任何地方√
}

• 修饰符修饰范围大小对比

public > protected > 缺省 > private

2.7.2、JavaBean

JavaBean {
    
    // 类是公共的
    // 有一个无参的公共的构造器
    // 有属性，且有对应的get、set方法
}

/* 说明：
   用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
 */

2.8、继承

2.8.1、继承的语法

class 子类类名 extends 父类类名 {
    
}

2.8.2、继承的种类

继承的种类 {
    
    单继承;   // Java只支持单继承，不允许多重继承
}

2.8.3、super

• super的使用

super {
    
    super.a = 10;             // 访问父类中定义的属性
    super.sayHello("hello");  // 调用父类中定义的成员方法
    super();                  // 子类构造器中调用父类的构造器
}

• this和super的区别

this和super的区别 {
    
    访问属性 {
        
        this;   // 访问本类中的属性，如果本类中没有此属性则从父类中继续查找
        super;  // 访问父类中的属性
    }
    
    调用方法 {
        
        this;   // 访问本类中的方法
        super;  // 直接访问父类中的方法
    }
    
    调用构造器 {
        
        this;    // 调用本类构造器，必须放在构造器的首行
        super;   // 调用父类构造器，必须放在子类构造器的首行
    }
    
    特殊 {
        
        this;     // 表示当前对象
        super;    // 无此概念
    }
}

2.8.4、重写

• 重写的定义

重写/重置/覆盖/override的定义 {
    
    // 在子类中可以根据需要对父类中继承来的方法进行改造。在程序执行时，子类的方法将覆盖父类的方法。
}

• 重写的要求

重写的要求 {
    
    // 重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。
    // 重写方法不能使用比被重写方法更为严格的访问权限。
    // 重写和被重写的方法必须同时为static，或同时为非static。
    // 子类方法抛出的异常不能大于父类被重写方法的异常。
}

2.9、多态

2.9.1、多态的体现

多态的体现 {
    
    // 方法的重载和重写
    // 对象的多态性，可以直接应用在抽象类和接口上
}

3、static关键字

3.1、static使用范围

static使用范围 {
    
    属性;
    方法;
    代码块;
    内部类;
}

3.2、被修饰后的成员具备的特点

被static修饰后的成员 {
    
    // 随着类的加载而加载
    // 优先于对象存在
    // 修饰的成员，被所有对象所共享
    // 访问权限允许是，可不创建对象，直接被类调用
}

// 注意：在static方法内部只能访问类的static属性，不能访问类的非static属性。
// 注意：在static方法内部不能有this和super。
// 注意：重载的方法需要同时为static或者非static。

3.3、非静态代码块和静态代码块

非静态代码块和静态代码块 {
    
    // 没有static修饰的代码块
    静态代码块 {
        
        // 可以有输出语句
        // 可以对类的属性、类的声明进行初始化操作
        // 可以调用静态的变量和方法
        // 若有多个非静态的代码块，那么按照从上到下的顺序依次执行
        // 每次创建对象的时候，都会执行一次。且先于构造器执行
    }
    
    // 用static修饰的代码块
    静态代码块 {
        
        // 可以有输出语句
        // 可以对类的属性、类的声明进行初始化操作
        // 不可以对非静态属性初始化。即：不可以调用非静态的属性和方法
        // 若有多个静态的代码块，那么按照从上到下的顺序依次执行
        // 静态代码块的执行要先于非静态代码块
        // 静态代码块只执行一次
    }
}

4、final关键字

4.1、final使用范围

final使用范围 {
    
    类;
    属性;
    方法;
}

4.2、final的特点

被final修饰后的特点 {
    
    // final标记的类不能被继承
    // fianl标记的方法不能被子类重写
    // final标记的变量（成员变量或局部变量）即成为常量。名称大写，且只能被赋值一次
}