面向对象

最新推荐文章于 2023-02-26 23:18:29 发布

李伦宇

最新推荐文章于 2023-02-26 23:18:29 发布

阅读量137

点赞数

本文链接：https://blog.csdn.net/SXtylly/article/details/95353180

版权

面向对象

面向对象与面向过程：

1.面向过程和面向对象都是一种编程思想,只是思维方式的不同；
2.面向过程:"如何完成|如何实现?"然后一步一步实现就可以了；
3.面向对象:"这件事情应该找谁来完成?"完成的这个人就是对象,不关注实现过程,只关注对象；
4.面向对象依托于面向过程。

面向对象的优点

1.面向对象的思维方式更贴近于现实生活的思维方式；
2.面向对象思维方式更体现于管理者,面向过程体现于执行者；
3.可以将复杂的问题简单化。

面向对象提出了2个概念

1.类:一类或一系列事物的模板(定义的是一系列事物的共性)；
2.对象：现实生活中真实存在的某个事物，但是没有类就没有办法创建对象。

使用自定义类

1.导包
1)java.lang包下的直接内容不需要导包
2)同包下的类不需要导包
2.创建这个类型的一个变量|引用
创建对象->new
引用数据类型变量名 = new 引用数据类型();
3.使用内容
变量名.属性名字
变量名.方法名字(实参)

对象的创建

new创建对象会执行的步骤:
1.在堆中为对象开辟空间,当前类的成员属性会跟随对象进入到堆内存并附默认值
2.调用构造器为对象初始化信息(一般为成员属性第一次赋值)
3.将对象的地址返回给引用

构造器|构造方法|构造函数:

作用:
初始化对象信息
定义:
修饰符类名([参数]){
…
}
1.没有返回值类型,没有void
2.可以根据需求存在return,提前结束方法
3.构造器不能和static,abstract,final一起使用

调用:
跟随new使用,是new其中的一步

1.如果没有显示构造器,编译器会隐式为你提供一个空构造；
2.如果存在自定义构造器,编译器不会再为你提供任何构造器, 包括空构造；
3.定义多个构造器,参数列表不同,构成构造器的重载,调用根据()中的实参匹配不同的构造器；
4.构造器的修饰符可以是private,私有的,只能在当前类中使用这个构造器；
5.根据不同的需求定义不同的构造器,一般都会存在至少一个空构造。

对象的内存分析

在这里插入图片描述

this关键字（代表当前对象）

作用：
1.this在构造器的首行调用其他构造器(本类中的其他构造器)，
this(参数)->匹配不同的构造器的参数
2.区分同名变量问题(成员变量与局部变量,参数之间同名问题)。
1）：this使用在构造器中,指代当前创建的对象
2）：this使用在成员方法中,this指代当前调用成员方法的对象。
3）：默认发生就近原则 .
注意点：
1.不存在同名变量|参数问题,变量就是指代成员,前面默认省略this.
2.调用构造器的时候this必须存在第一行才行
3.构造器之间不能相互调用
4.this不能使用在static修饰的内容中

static关键字（静态的成员修饰符）

1.static修饰变量：只能是成员变量,不能修饰局部变量
2.static修饰的方法：静态方法，

静态的内容的使用方式:

类名.方法名([参数列表]);
类名.属性名;
对象.方法名字([参数列表]);
对象.属性名;
注意点：
1.被static修饰的静态的内容是属于类的,可以通过类使用,也可以通过对象去使用
2.成员的内容是属于对象的,成员变量,成员方法只能通过对象调用
3.静态的内容中只能直接使用静态的内容,成员内容需要通过对象使用
4.非静态的内容中,可以直接使用静态的内容,也可以直接使用非静态的内容
5.只在类第一次加载的时候初始化一次,静态的内容是独一份的,所有的对象共享一个类中的静态内容

块block（{}->作用域）

1.{}定义在方法中->局部代码块|普通语句块
执行时机:调用方法时
2.定义在类中方法外->构造块
执行时机:new对象的时候
3.static{}定义在类中方法外->静态块
执行时机:在类第一次加载以后执行一次

注意点

1.构造块先于构造器的代码执行,如果存在多个构造块,从上到下依次执行
2.静态块先于主方法执行,如果存在多个静态块,从上到下依次执行，如果存在静态块,静态变量,从上到下依次执行
3.执行顺序：static->main->构造块->构造器
4.编译时，编译器会将构造块放在编译器的第一行。
源码：

public class BlockTest {
	public static int a = 0;
	{
		a = 10;
		System.out.println("3 ,非静态代码块执行a="+a);//10
	}
	static {
		a = 6;
		System.out.println("1 ,非静态代码块执行a="+a);//6
	}
	public BlockTest(){
		this(a);//
		System.out.println("6, "+a);//10
		System.out.println("7,无参构造方法执行a=" +a);//10
	}
	public BlockTest(int n){
		System.out.println("4, "+n);//6
		System.out.println("5, "+a);//10
	}
	public static void main(String[] args) {
		System.out.println("2 ,main");//
		BlockTest tsc = new BlockTest();
	}
}

反编译器编译后：

public class BlockTest {
  public static int a = 0;



  
  static  {
    a = 6;
    System.out.println("1 ,a=" + a);
  }
  
  public BlockTest() { this(a);
    System.out.println("6, " + a);
    System.out.println("7,a=" + a); } public BlockTest(int paramInt) {
    a = 10;
    System.out.println("3 ,a=" + a);
    System.out.println("4, " + paramInt);
    System.out.println("5, " + a);
  }
  public static void main(String[] paramArrayOfString) {
    System.out.println("2 ,main");
    BlockTest blockTest = new BlockTest();
  }
}

垃圾回收机制

System.gc() 通知垃圾回收机制来回收垃圾

是否回收,什么时候回收手动控制不了
finalize()方法如果回收垃圾,第一步会调用这个方法
一定会调用finalize()方法的情况:
1.匿名对象
2.对象无引用状态

import 导包

import java.包名.类名
import java.util.*;模糊匹配,一个包下的所有类,降低编译效率,不会降低运行效率
import java.util.Scanner; 静态导入:导入静态的内容(属性|方法)

注意

不要定义与 jdk 相同的包，相同的类，否则会引起很
多你觉得莫名其妙的问题

封装

关键字 private 私有的成员修饰符，不能修饰局部

被private修饰的内容,只能在当前类(本类)中使用
提供:公共的访问方式设置器 setter 访问器:getter— 方法
私有的内容特点：
1.不允许直接操作属性
2.访问方式中可以逻辑判断

属性私有化是封装的具体的体现
私有是封装,但是封装不仅仅是私有，方法,类都是封装的体现
封装定义：隐藏内部的实现细节,对外提供公共的访问方式。
优点:

隐藏实现细节
提高程序的安全性
提高程序复用性
*标准的javabean类要求:
1.类公共的被public修饰
2.属性私有
3.公共的设置器和访问器
4.至少有一个空构造

继承（子承父业）

父类|基类|超类
子类|派生类
使用继承的目的:

为了提高代码的复用性
如何使用继承:
定义子父类,使用extends关键字子类 extends 父类
定义父类:抽取一系列子类的功能,定义为父类
作用：延续+扩展
子类一旦继承父类,就能够使用父类中的内容
子类可以定义自己独有的内容,扩展父类的功能
java中类只能单继承,可以多实现
单继承的优点:
使用简单
单继承的缺点:
局限性大,不便于后期维护
继承遵循开闭原则（面向对象的设计原则之一）：
对修改关闭,对扩展开放

super 和 this

super:指代父类对象
super使用在构造器的首行,调用父类的某个构造器
super(参数列表)
使用在首行:
默认在子类构造器的首行会调用父类空构造,如果显示定义super(参数),不会再默认调用父类空构造了
需求:
当创建父类对象时,需要使用父类中的其他构造器,通过super(参数)显示定义调用哪一个,否则默认调用空构造
注意:
this和super不能同时存在与构造器的首行调用构造器,除了显示定义this(),隐式调用super(),仅仅调用父类空构造
区分同名问题
如果存在子父类中成员同名问题,默认调用子类的,就近原则
如果不存在同名,默认调用父类,相当于省略了super.

this和super都不能使用在static内容中

创建对象:
先父类后子类(默认创建的父类对象在子类的内存空间中,外部无权使用默认创建的在子类内存中的父类对象,如果需要使用父类对象,自己手动创建父类对象)

权限修饰符(内容被访问的权限)

private:只能在本类中访问
default：在本类和同包类中访问
protected：在本类和同包类以及不同包子类中访问
public :在本类和同包类以及不同包子类和不同包其他类访问
成员修饰符,不能修饰局部
能够修饰类:public|default(隐式定义)
私有的内容是不能继承的

Object类

老祖宗类，所有的类的父类
java中的类肯定会直接或者间接的继承自Object。
toString() 把对字符串的形式显示
当打印对象的时候,默认会调用toString方法，
默认调用Object类型的toString方法,打印对象的地址
如果想要获取所有属性值,在子类中重写toString()方法,自定义返回值的内容
equals() 比较对象是否相等
== 和 equals的区别:
==比较对象的地址
equals 如果使用Object类中的equals方法实现,比较的还是对象的地址
通过方法的重写,在子类中重写equals方法,自定义比较规则,实现比较对象的内容非地址
因为:比较对象的内容,一般认为所有成员属性的值|某些成员属性值相同,就是一个对象

final关键字

1.被final修饰的变量为常量,不能修改
2.被final修饰的方法不能被重写
3.被final修饰的类不能被继承,太监类

重写

重写与重载的区别:
1.不同的类
2.继承关系|实现
3.方法签名相同(方法名+参数列表)

测试一个方法是否为标准的重写方法:
1.重写方法左边会出现三角形
2.@Override 强制检测是否为重写方法

为什么要使用重写?
父类的功能你也有,但是实现体不一样,就可以对这个功能在子类中进行重写

调用:
如果子类中有重写方法,会调用子类的,否则调用父类的–就近原则

要求:
== :方法签名完全相同
<= :返回值类型如果是基本数据类型必须相等,如果是引用数据类型,子类<=父类
>= :权限修饰符子类>=父类
不能被重写的方法:
1.被private修饰的方法不能被重写
2.被final修饰的方法不能被重写
3.被static修饰的方法不能被重写
注意:
如果子类中定义的方法名与父类静态方法的方法名相同,子类这个方法也要被static修饰,但是却不是重写方法

抽象：abstract

抽象类 : 被abstract修饰的类
抽象方法 : 被abstract修饰的方法，没有方法体，必须存在抽象类中
注意:
1.抽象类不能实例化
2.抽象方法必须存在于抽象类中
3.抽象类中可以存在抽象方法,可以存在具体方法(有方法体的方法)
4.通过子类使用抽象类:
具体子类:重写抽象父类中的所有抽象方法+按需新增
抽象子类:按需重写抽象方法+按需新增
5.一个抽象方法如果已经被重写过,就可以不需要再次重写
6.抽象方法必须被重写
7.abstract不能和static, final,private,native一起使用

内部类

定义：
类中定义类，一个类中的某个成员,也为一个事物,可以把这个事物定义为一个类,内部的这个类就是内部类
分类:

局部内部类:
1.局部内部类不能使用成员修饰符修饰 public …static…(final不是成员修饰符)
2.局部内部类只能在所定义的方法中使用
3.如果定义局部内部类的方法有参数,在内部类使用这个方法的参数,这个参数只能被final修饰 1.7及之前必须显示定义final,1.8可以省略,默认final修饰
静态内部类:静态的内部类中可以定义静态的内容
静态的内部类中不可以直接使用外部类的成员,因为内部类是静态的,通过对象使用
私有内部类:私有的内部类只能当前的外部类中使用,其他类中无法使用
匿名内部类:当有些类没有自己的作用,只是对有些方法进行重写,可以简略的使用匿名内部类的形式
成员内部类:内部类定义在外部的成员位置
成员:可以使用成员修饰符 public…static…
类:可以实现接口,继承类
内部类中可以使用外部类中的所有内容的(包括私有的)
成员内部类中不能定义静态的内容除了静态的常量
外部类中通过内部类对象使用内部类中的成员

接口

interface定义的特殊的抽象类
在1.7及之前:
静态的公共的常量+公共的抽象的方法
属性:
public static final默认修饰符,可以选择性的省略
功能:
public abstract 默认修饰符,可以选择性的省略

1.8及之后版本:
1.静态方法:接口名字. 使用
2.默认方法:实现类的对象使用

注意:

1.类的继承,接口需要实现
2.抽象方法必须被重写
3.使用接口中的内容:接口需要实现implements,类要使用extends继承
具体的实现类: 重写接口中的所有抽象方法+按需新增
抽象的实现类: 按需重写抽象方法+按需新增

4.单继承,一个类只能继承一个类,接口可以多实现,实现了接口,就拥有了接口中定义的功能
5.一个类即继承父类又实现接口,先继承后实现
6.避免实现的多个接口中定义了相同的功能
7.接口可以多继承其他接口,不能是实现接口的(实现:对抽象方法方法体的实现)
8.接口不能实例化

接口的优点:

避免单继承的局限性 (推荐使用接口)
提高代码的复用性
解耦:高内聚低耦合
定义规范
多态:一种事物的多种形态|多种表现形式
多态的前提:
类的继承
接口的实现

多态的体现|表现形式:

父类的引用指向子类对象
多态的使用:
父类的引用在调用方法,调用子类中重写的方法
注意:
父类引用对子类新增功能不可见
如果子类中没有重写方法,多态没有意义
多态使用成员:
成员变量:
编译运行看父类|左边|类型
成员方法:
编译看父类,运行看子类
编译看类型,运行找对象
编译看左边,运行看右边

转型: java是一门强类型的语言

基本数据类型: 自动类型提升强制类型转换
引用数据类型: 向上转型(自动) 向下转型(强制)
小范围类型–>子类
大范围类型–>父类
向下转型:当需要调用子类独有的功能,需要向下转型
避免向下转型转型错误,出现类型转换异常的问题，引用 instanceof 类型
引用 instanceof 类型
判断前面的引用是否为后面类型的对象|子类的对象
如果是,返回true,如果不是,返回false
编译只检查引用的类型与后面的类型是否在一条继承链上,如果是就语法没有错误
面向对象:三大特性
封装: 隐藏内部的实现细节,对外提供公共的访问方式
继承: 子类一旦继承父类,就自动拥有父类的内容+子类的扩展
多态: 结合继承,和方法的重写,封装可以提高代码的复用性和扩展性