Java面向对象节到总结细

面向对象概念
面向过程&面向对象都是处理思考问题的方法
面向过程概念:思考问题更加侧重与实现的过程,比较适合处理小型问题
面向对象概念:以决策者的角色思考问题, 比较侧重于’谁来处理’,比较适合处理中大型问题

面向对象和面向过程不是并不是完全独立的,一般来说宏观上先用面向对象的思想思考问题,细节上使用面向过程思考方式

面向对象的实现的思路
通过问题名词抽取法—>共同的行为属性抽象为类—>创建类—>创建对象
如下图:

类&对象的理解
java最基本元素是类&对象
对象的理解:
客观世界存在的一切可以描述的事物,都称之为对象
类的理解:
对一类事物的描述,是抽象的 概念上的定义;是具有相同属性的方法的对象的集合,就是一类对象的抽象

如何区分对象:
通过对想的特征(属性&方法)
属性:描述对象的静态,外观的特性,比如 姓名 身高 价格等
方法:描述对象的行为或者功能 比如喝 学习 睡觉等

类&对象的创建和使用
类的创建语法:
[修饰符] class 类名{
//属性定义和变量定义相同
属性
//该类的功能
方法
}

对象的创建
类名 对象名 = new 类名();
使用:
对象名.属性名= 值;
对象名,方法名();

类&对象的存储
引用数据类型:String Array 类
创建对象的过程
a. 看看内存中是否有该类(以及父类后续继承会讲到),没有的话,类加载器加载类到方法区
b. 创建对象
内存中创建如下图:
注意:方法区只说明有那些属性,没有开辟空间,创建对象的时候开辟空间

结论:

类的成员
类的成员包括成员属性 & 成员方法
成员变量特点以及和局部变量区别:

而且全局变量可以用public修飾，局部变量不能使用
全局变量有默认值局部变量没有

成员方法:
方法理解&好处:

方法可以理解为行为或者功能,描述一组对象的行为和功能

方法的五要素

方法的五要素包括 修饰符& 返回值类型&方法名&参数列表&方法体
修饰体 返回值类型 方法名 (参数列表){
方法体
}

方法的调用
不同一个类中:

对象名.方法名

同一个类红

方法名();

方法的调用机制
包括方法的入栈出栈

方法的重载
注意和返回值无关系,参数类型自动向上转型

访问修饰符号
说明:protected修饰符修饰一个类的成员变量时候,该成员变量在同一个包可见,不同包但是是原来类的子类也可以直接访问,不需要创建对象访问

这里注意四中访问修饰符值针对类的成员的,不是类
类只有俩种访问修饰符public default

构造器
构造器又称之为构造方法,本质上是一个方法,就是没有返回值也不能通过对象显示调用
构造器语法

//方法名为类名
//特殊方法 没有返回值
修饰符 方法名(参数列表){
方法体
}

构造器作用特点:

1. 创建对象
2. 一个类中默认有一个无参构造
3. 如果有有参构造,无参构造不写会被覆盖
4. 有参构造可以进行初始化操作
5. 对于任何对象来说构造器只可能调用一次
6. 一个类容许多个构造器

this关键字
创建有参构造器的时候, 为了防止构造器局部参数和成员属性重名,这里出现this
this代表当前类对象

继承
继承详解

多态
概念

一种事物(java中指对象&方法)有多种表现形式

生活中多态

多态的变现形式

1. 方法的多态
方法的重载 方法的重写
2. 对象的多态(对象的转型)
一种对象多种表现形式
List list = new ArrayList();
编译类型和实际类型不一样,就是对象的多态,也是对象的转型

对象多态(对象的转型)语法
先看基本类型转换

对比基本类型转换,这里看看引用类型转换
这里看对象的强制类型转换(对象的多态)

List list = new ArrayList();
这种为啥叫多态,因为对象编译类型为List
运行类型为Arraylist,对象出现了多种状态, 就是对象的多态

编译类型和运行类型可以这样理解

List list = new ArrayList();
编译类型看左边,运行类型看右边  
List 的引用指向了Arraylist 的对象

多态的应用

1.  多态数组
原则上数组只能放相同类型
在引用类型数组上,使用多态存放数组,数组元素可以是父类和子类多种形式,数组里面容纳的元素更多了
2.  多态参数
形参的类型为父类类型,使用多态传递参数

多态数组易用的案例:

多态参数使用案例:

Object 类详解
Object类详解地址

Static 关键字
(1) static 修饰符使用位置:
static 是一种静态的修饰符,可以修饰类的属性(属性, 方法, 内部类, 初始化块)不能修饰构造器和局部变量
使用static修饰的成员称之为静态成员,比如静态方法 静态方法
没有使用static修饰的成员称之为普通成员,比如普通属性 普通方法
静态属性加载

(2)static 的特点
静态属性特点:其中一个对象修改,影响另一个对象,多个对象共享该变量,当该类所有对象该值一样,就可以定义为static
静态属性和普通属性区别:

一般静态属性使用情况: 当该类某属性所有对象都具有同样的值不轻易更改
PI 银行利率等
静态方法
静态方法和普通方法的相同

static 方法不能被重写

一般工具类的功能方法,不涉及对象的属性,一般设计为静态方法
静态成员的总结:

单列设计模式
设计模式简述

单例设计模式

单例设计模式包括俩种: 饿汉式+懒汉式

饿汉式和懒汉式的代码实现:

/*饿汉式: 类加载的时候对象就已经创建了,比如调用静态成员pi时候对象就创建了
饿汉式线程安全*/
class Single1 {
    public static double pi;

    //1. 构造器私有化
    public Single1() {
    }

    //2 本类内部创建对象 因为Single1getInstance方法内要调用,所以使用static修饰
    private static Single1 s1 = new Single1();

    // 3 暴露对象
    public static Single1 Single1getInstance() {
        //说明 静态方法里面没有this 所以不能调用普通成员
        return s1;
    }
    
}

懒汉式代码★★★
缺点:存在线程安全问题

//懒汉式: 调用方法时候才创建对象
class Single2 {
    
    //1. 构造器私有化
    private Single2() {
    }

    // 2 本类内部创建对象
    public static Single2 s2;

    // 3 暴露对象
    public static Single2 getInstance() {
        if (s2 == null) {
            s2 = new Single2();
        }
        return s2;
    }
}

懒汉式代码改编
解决线程安全问题

class Single {
    //1. 构造器私有化
    private Single() {}
        // 2 本类内部创建对象
    private static Single single;
        // 3 暴露对象 供外部调用
   public static Single getSingle() {
        if (single == null) {
            synchronized (Single.class) {

                if (single == null) {
           
                    single = new Single();
                }
            }
        }
        return single;
    }
}

饿汉式案例Runtime 类

public class Runtime {
    //2: 类内部创建对象
    private static Runtime currentRuntime = new Runtime();
    /3:方法用來暴露对象
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    //1. 私有构造器
    private Runtime() {}

final 关键字
final 是一种修饰符,用于修饰类, 成员属性,成员方法,局部变量

1.  当final 修饰类: 该类不能继承,即该类没有子类例如String，Integer等包装类,提高代码安全性
2.  当final 修饰方法: 方法不能重写,但是方法可以被继承
3.  当final 修饰属性&局部变量:该变量变为常量,里面的值一旦赋值就不能更改★, 修饰属性,需要注意
    a. final 修饰的成员属性,一般是大写,表示常量属性
    b. 一般来说final & static 一起使用修饰常量

总结static 修饰属性意思所有对象共有变量,类加载时加载,类名调用
final 修饰属性意思该属性值不可以更改,常量
编译看左边,执行看右边

初始化块
初始化块又称为代码块,本质上是一个方法,也有方法体,没有方法名参数没返回类型,也不是通过对象或者类名显示调用,而是通过隐式调用
[static]{
方法体
}
使用static修饰的称为静态初始化块,静态代码块,
没有static修饰的称为普通初始化块
方法体内可以有任意逻辑(输入输出,变量运算等)

好处:
1.  用于初始化信息的,这方法类似构造器,相当与构造器的补充
2.  但多个构造器有重复语句,可以将重复语句提取到方法块中,提高重用性

类的加载时机

1.  创建对象的时候,类会加载
2.  调用类的静态属性的时候类会加载
3.  创建子类的时候,父类会被加载

普通代码块vs 静态代码块

1.  静态代码块在类加载的时候调用
2.  普通代码块在对象创建时候调用
3.  静态代码块只执行一次,普通代码对象创建一次调用一次
4.  一个类中,能有多个静态代码块,多个普通代码块,执行时先调用静态代码块
5. 一个类中,有普通属性初始化,静态属性初始化,普通代码块,静态代码块
静态属性初始化/静态代码块初始化--->普通属性初始化/普通代码块初始化-->构造器
内部定义顺序执行
6. 子父类都有普通属性和静态属性, 普通代码块和静态代码块

抽象类&抽象方法
abstract 关键字的理解

1. 可以修饰类 方法,但是不能修饰属性 局部变量  构造器
2. 抽象类 抽象方法
3. 抽象类一般为父类,父类里有不好描述的方法,往往这些类设计为抽象类

使用特点

1.  抽象类不能创建对象,抽象类类似半成品
2. 抽象类有构造器,因为子类构造器默认会调用父类构造器,所以抽象类必须有构造器
3. 抽象类可以有普通成员
4.  抽象类可以没有抽象方法
5. final 不能修饰抽象类,因为abstact 类就是要被继承
6. 抽象方法可以没有方法体public abstract void eat();
7. 抽象类的子类必须重写父类的抽象方法,因为普通
8. 抽象类可以有抽象子类,可以不用实现里面的抽象类

接口
概念

特点

使用

内部类