javaSE 总结之面向对象思想

方法

Method

封装了特定功能的代码块
psvm…就是main方法的声明

返回值 : 方法执行完毕后结果 要求结果的数据类型必须和返回值类型一致
无返回值 : 方法执行完毕无结果
返回值类型 : 用来约束方法返回值的数据类型

形参 :调用方法时需要给方法提供的数据(方法名后面小括号内容)形式上参与运算
无形参 :调用方法时不需要给方法提供数据

void : 代表方法无结果
方法名: 小驼峰
() :形参列表

return : 结束方法,并把方法的结果返回给调用者
有返回值方法 必须写return 后面要跟上方法的结果
无返回值方法 可以写return 后面不可以接数据
只有一个返回结果

无形参无返回值方法

public static void 方法名(){
//方法体:完成功能的代码
}

无返回值有形参的方法

public static void 方法名(形式参数列表){
//方法体;(特定功能的代码)
}

有参有返回值方法

public static 返回值类型 方法名(形式参数列表){
//方法体;(特定功能的代码)
return 返回值;

有返回值无参数方法

public static 返回值类型 方法名(){
//方法体;(特定功能的代码)
return 返回值;
}

形参和实参

形参 : 定义方法的小括号内
形式上与方法内的逻辑运算
接收调用方法时传入的实参
要什么给什么 要多少给多少 怎么要怎么给

实参 : 在调用方法的括号内
具体参与运算的数据(变量常量)-要和形参匹配
给形参赋值的

方法的调用格式

无返回值方法 : 只能直接调用
有返回值方法 :
直接调用 : 方法执行了,但是忽略了结果—无意义
输出调用 : 可以在控制台看到结果----有意义但是不能对结果进行下一步操作
接收调用 : 返回值类型 变量名 = 方法名(实参) ----用这个好

注意事项

1. 方法一定要定义在类中其他方法的外面;
2.  方法要先定义后使用!! 方法不调用不执行!!
3. 方法名和变量名可以同名,因为方法和变量是不同的两个物种!
4. 当方法有形参,调用方法时给与实际参数
     	要什么给什么,要多少给多少,怎么要怎么给
5. 形参和实际参数的变量名不需要相同,主要关注 形参的个数,类型,类型顺序是否和实参给与的一样  
6. 一个方法可以有多个return,但是只可能有一个return被执行

方法的重载

Overload
你在一个类中,看到有多个同名的方法且不报错,那么我们称这个方法出现了方法重载的现象
重载的前提:
1. 必须在同一个类中
2. 方法名必须相同
3. 形式参数列表不同
个数不同
类型不同
类型顺序不同
4. 与返回值类型无关
5. 与形参的变量名无关

方法重载现象的出现是为了 调用者方便的调用方法的!!
    现阶段: 用的多,定义的少!

如何调用重载方法?
    只需要传入正确的实际参数,JVM会根据传入的实际参数匹配最优的方法启动   

经验

1. 方法名是红的 : 说明没有这个方法!!
   2. 实参位置报错 : 实参给的不对!!
   3. 整个调用方法的语句都报错 : 调用方式出了问题
   无返回值方法: 只能直接调用
   有返回值方法:
   1. 可以直接调用
   2. 可以输出调用
   3. 可以赋值调用 √

面向对象

思想

思想 : 想法,思维方式 -> 思想决定行为

编程思想 : 编程时的一种思维方式 -> 决定了如何写代码
//面向 : 重视,更看重
面向过程 : 凡事必躬亲
面向对象 : 自己的事情别人做, 懒人思维
面向函数 : 基于面向对象的,面向对象的升级版
面向切面 :
//高级的编程思想都是为编程提供遍历

面向对象编程思想: 自己的事情别人做, 懒人思维
面向对象思想是基于面向过程编程思想的升级;

特点

面向对象思想的核心特点:
1. 更符合平时的思维习惯
2. 把复杂的问题简单化
3. 把我们从执行者变成指挥者

面试回答

我理解的面向对象思维是更符合平时思维习惯的一种思维方式,它可以把复杂的问题简单化,可以把我们从执行者变成指挥者,在Thinking in Java这本书中对面向对象思维描述用到了 万物皆对象;面试官您面试的整个过程涉及到了很多面向对象思维的应用,面试官您面试肯定是因为公司项目有了新的或者更多的需求,以您的实力完全可以一个人完成,但是您有更重要的工作需要去主持,所以老板就使用了您面试的功能来招聘一些具备开发功能的人例如我帮助您完成需求;面向对象思维在工作场景中的应用,应用时遇到的问题,如何解决的…

封装

类和对象的关系

以类的方式组织代码 以对象封装数据
类是对象的模板,对象是该类事物的具体化

事物描述类

描述 : 属性描述信息 成员变量 : 定义在类中方法外的变量
行为 : 描述功能 成员方法 : 定义在类中方法外的方法
所有的方法都是成员方法

使用事物描述类 :
创建 : 类名 对象名 = new 类名();
对象调属性/方法都是. 点就是调

成员变量和局部变量

**
因为在类中的位置不同,导致作用域不同和导致在内存中的位置不同;
因为在内存中的位置不同,导致初始化值不同和生命周期不同; **

颜色不同
没使用 : 都是灰色
使用了
成员变量 : 粗紫色
局部变量 : 细黑色

private关键字

权限修饰符 私有 成员变量.成员方法
修饰过的只能在本类中访问

变量访问的就近原则

局部位置 < 本类成员位置 < 本类父类的成员位置

构造方法

构造方法就是创建方法

注意事项

1. 构造方法没有返回值类型板块,构造方法调用完毕必然生成的是本类的对象
   2. 构造方法的方法名必须和类名一致 (大小写也要一致!)
   3. new 的本质是在创建对象,其实也是在调用构造方法
   4. 如果一个类中没有写任何构造方法,JVM默认赠送一个无参构造(没有形参的构造方法)
   5. 如果在一个类中写了任意一个构造方法,默认赠送的无参构造就不送了
   6. 构造方法也可以构成方法的重载
   7. 没有参数的构造称 无参构造,有参数的构造称 带参构造
   8. 有参构造可以在创建对象的同时给属性赋值

定义事物描述类

1. 私有所有的属性
2. 自动生成无参构造
3. 自动生成全参构造
4. 自动生成 getter and setter 方法

//事物的行为根据需求来

//alt + insert

static关键字

静态的
可以修饰成员变量和成员方法

1. 被static修饰的成员被所有对象共享
2. 被static修饰的成员能被类名直接调用
3. 被static修饰的成员优先于对象加载的
4. 被static修饰的成员随着类的加载而加载的

静态成员

静态成员方法只能访问静态成员变量和静态成员方法; 静态虽好但只能访问静态!

为什么静态只能访问静态? 因为静态成员随着类的加载而加载优先于对象,而非静态成员是属于对象的,静态成员加载时,对象还没有产生,所以不能访问

static方法中不可以用this关键字 ? this代表的是对象的引用,而static方法加载时还没有对象,何来引用??

所有的成员变量和成员方法都可以用static修饰

继承

特点

子类继承父类可以使用父类所有菲斯有的成员
子类要加载优先加载父类
一个子类只能有一个父类
一个父类可以有多个子类
父类可以有直接的父类
父类对象不可以使用子类成员(父亲不知道有这个儿子)

extends关键字

public class 父类名 {
}

public class 子类名 extends 父类名 {
}

访问特点

继承关系下成员变量的访问特点

就近原则

1. 在父类中访问 : 只能访问父类中有的成员变量, 子类访问不到
2. 在子类中访问 : 可以访问子类自己的和父类非私有的成员
   this: 打破局部的约束,强制访问本类成员位置上的变量
   super:打破本类成员的约束,强制访问本类父类成员位置上的变量
3. 在第三方类中访问 : 子类对象只能访问父类所有非私有的成员和自己本类中的成员

成员方法的访问特点

 继承关系下成员方法的访问特点: 真正对象是哪个,就调用哪个对象的方法
    1. 在父类中访问: 父类不能访问子类成员
    2. 在子类中访问: 子类可以使用父类所有非私有的成员
        若想强制访问本类父类同名方法,需要在方法调用的前面加super : super.方法名();
    3. 在第三方类中访问:
            子类调用和父类同名的方法时,优先调用子类自己的

构造方法的访问特点

子类对昂要加载优先加载父类

1. 每一个构造方法的第一句都隐藏着 super();
   super(): 调用父类的无参构造
   2. super()类似语句必须是构造方法的第一句有效代码
   3. 一个构造方法内只可以使用一次super()类似代码
   4. 除了有super()之外还有super(实参),this(),this(实参)
   super():调用本类父类无参构造
   super(实参): 调用本类父类有参构造
   this():调用本类的无参构造
   this(实参):调用本类的有参构造
   5. 如果说你使用了 super(实参) ,this() ,this(实参)中的任何一个,默认赠送的super()就不送
   6. 在子类的构造方法中调用其他构造方法,必须有一个构造中是去加载父类!!

方法的重写Override

当父类新闻的方法不能满足子类使用的时候,就可以在子类中重写父类的方法,覆盖父类的方法体

特点

必须有继承/实现关系
子类方法和父类方法的声明完全一致
方法名必须一致
形参列表必须一致
方法体可以不一样
子类的重写方法权限修饰符必须大于等于父类方法
public > protected > 不写 > private

返回值类型
void : 必须一样
基本数据类型 : 必须一样
引用数据类型 : 子类重写方法的返回值类型必须是父类方法的子类或者同类
Integer < Number < Object

注解@Override
static没有重写概念

this和super

this : 本类对象的引用
哪个对象调用含有this的方法,this就代表那个对象 --> 对象调方法: 对象照镜子,镜子里是谁this就是谁

super : 本类父类对象的引用
哪个对象调用含有super的方法,super就代表那个对象的某个父类对象 -> 对象调方法 : 对象照镜子,镜子里出现的是此对象的某个父类对象,而这个父类对象就是super

this.变量 : 打破局部约束,强制访问本类成员位置的变量
this.方法(实际参数) : 调用本类成员位置的方法 -> 不会写!!所有的方法都是成员方法
this() : 调用本类的无参构造方法
this(实际参数) : 调用本类的有参构造方法

super.变量 : 打破本类成员的约束,强制访问本类父类成员位置上的变量
super.方法名(实际参数) : 调用本类父类的成员方法 -> 会用!!
super() : 调用本类父类的无参构造方法 -> 构造方法的默认第一句代码
super(实际参数) : 调用本类父类的有参构造方法

九阳神功

第一式 : 只要看到了对象调,找到对象创建的位置(观察对象创建的语句)

第二式 : 看对象在调什么
对象调属性(成员变量):
对象调方法(成员方法):
对象调静态成员(静态成员变量和静态成员方法):

第三式 :
对象调属性(成员变量): 编译看左边,运行看左边;
对象调方法(成员方法): 编译看左边,运行看右边;
对象调静态成员(静态成员变量和静态成员方法): 编译看左边,运行看左边;

继承的好处和弊端

好处
子类往父类看 : 抽取共性到父类中,提高代码的复用性
父类往子类看 : 子类父类后,可能功能得到拓展

弊端
内聚 : 独立完成功能的能力
耦合 : 和别人的联系和关系 -> 依赖关系
有继承就用

final

最终的类 : 没有子类
最终的成员变量 : 此变量不能修改 -> 自定义常量
最终的成员方法 : 此方法不能被重写
最终的局部变量 : 此变量不能修改 -> 局部的自定义常量 -> 实时final

自定义常量 : 必须赋予初始化值,不能被修改
自定义常量的定义格式 : public static final 数据类型 常量名 = 初始化值;
常量名的命名 : 全部大写,多个单词用_分割

作用在 : 类 , 成员变量 , 成员方法 , 局部变量

抽象类

abstract
作用在类,方法
类是事物的抽象
抽象类比类更抽象
当多个子类中的共有行为在父类中不好编写方法体,可以把这个共有方法在父类中定义成抽象方法,而抽象方法必须存在于抽象类中,所以有了抽象类;

成员

都可以有也可以有多个
构造方法 : 可以有也可以有多个
抽象方法 : 可以有也可以有多个

区别

抽象类和普通类的区别在:
    1. 抽象类虽然有构造方法但是不可以创建对象
    2. 抽象类中可以有抽象方法
    3. 抽象类和类之间是继承关系

使用

抽象类一般都是作为父类的存在,约束子类的行为!

抽象方法

抽象方法 : 没有方法体的方法

格式
public abstract 返回值类型 方法名(形参列表);

父类中有抽象方法,子类必须重写父类的抽象方法或者子类自己也变成抽象类!

接口

比抽象类更抽象的"类"叫接口
类和类: 继承 -> 单一继承,多层继承
类和抽象类: 继承 -> 单一继承,多层继承
类和接口: 实现 -> 多实现

打破了java继承的单一性

接口的存在意义 : 提供规范/规则,对子类/实现类的行为做约束
接口的存在意义 : 提供功能的拓展
要提供规则就要公开规则 -> 为什么接口中绝大部分成员都是默认 public 修饰

多态

前提

必须有继承或实现关系
有方法的重写 : 动态绑定
父引用指向子类对象

特点

成员变量 : 就近原则
成员方法 : 对象是什么就调用谁的方法 -> 动态绑定
构造方法 : 子类对象要加载优先加载父类

弊端

父引用不能访问子类的特有成员,父引用只能调用和子类共有的成员;

类型转换

Java引用数据类型子父类之间类型转换的问题;
向上转型: 自动
父类/父接口 父引用 = new 子类();
//以多态的形式创建的对象
向下转型: 格式
子类型 子引用 = (子类型)父引用;

向下转型的弊端

ClassCastException: 类型转换异常
提前判断
1. 父引用 instanceof 类型 : 判断前面的父引用所接受的真实对象类型是否是of后面的类型 --> 返回boolean类型结果
if(父引用 instanceof 类型){
//向下转型
}
2. 父引用.getClass() -> 获取对象的字节码对象
类名.class -> 获取类的字节码对象
一个类只可能有一个字节码对象
if(父引用.getClass() == 类名.class){
//向下转型
}

使用场景

    1. 拿父引用作为方法的形参,启动方法的方式有n+1种
        n : 此父类有多少种子类 1 : 父类自己
    2. 拿父类型作为方法的返回值类型,返回方法结果时可以有n+1种对象类型返回
    3. 拿父类型作为容器的数据类型,容器中的数据类型就可以是n+1种
        Object[] objs = new Object[10];
        ArrayList<Object> list = new ArrayList<Object>();

匿名内部类

匿名内部类 : 匿名内部类匿掉的是内部类的类名;

当一个类的子类/一个抽象类的子类/一个接口的实现类只使用一次,那么我们没有必要专门准备一个java文件在存储子类内容,我们可以使用 匿名内部类简化代码!!

new 父类/抽象类/接口 (){
	//子类/实现类的类主体
};

权限修饰符

	同一个类	同一个包不同类	不同包有继承关系的类	不同包
private	√
不写	√	√
protected	√	√	√
public	√	√	√	√