面向对象编程三大特征

面向对象编程三大特征：

1.封装encapsulation

把属性(抽象出来的数据)和方法(对数据的操作)封装在一起，程序其他部分只能通过方法(被授权的操作)对数据进行操作。

隐藏实现细节，可以对数据验证，保证安全。

（public）set方法属性=参数名；

（public）get方法，返回return xxx；

set写到构造器中，可省略前面的this.

JavaBean的写法

成员变量私有化
提供getter setter方法
toString方法来描述对象
构造方法（无参）必须有
equals和hashCode
主要作用是运送数据

2.继承extends

提高代码复用性，扩展性和维护性

class 子类 extends 父类{}

子类又叫派生类

父类又叫超类，基类

3.多态ploymorphic

同一种的不同事务的同一行为的不同表现形态

多态的实现的前提

存在继承关系
存在方法重写
存在向上转型

建立在封装和继承之上

方法多态

重写，重载

对象多态

多态的特点：

提高代码扩展性
完全忽略了个性，只关注共性

一个对象的编译类型和运行类型可以不一致

编译类型在定义对象时就确定了，不能改变

运行类型可以改变

=左边☜是编译类型，=右边☞是运行类型

多态的实现的前提
- 存在继承关系
- 存在方法重写
- 存在向上转型
多态成员访问的特点
- 成员变量：编译看左边（基类），运行看左边（基类）
- 成员方法：编译看左边（基类），运行看右边（派生类），动态绑定
- 静态方法：编译看左边（基类），运行看左边（基类）
- 构造方法：创建子类对象时，访问父类的构造方法，对父类的数据进行初始化

继承天生就有，实现后天补充

‍

instanceof

对象运算符(instanceof)用来判断一个对象是否属于某个指定的类或其子类的实例，如果是，返回真(true)，否则返回假(false)。‍

类的5大成员

属性
方法
构造器
代码块
内部类

内部类

定义在外部类****局部位置上：
1. 局部内部类（有类名）
- 内部类可直接访问外部类的所有成员
- 外部类访问内部类，要先创建一个对象
- 不能添加修饰符，但可以用final
- 重名时就近原则，外部类名.this.成员（强制使用外部类成员名）
1. 匿名内部类（没有类名）
- 局部内部类的简化，本质是一个接口，同时也是一个对象
- 只能用一次，通常被定义在外部类成员位置上，和方法同一层级
- 匿名内部类不能有构造方法，不能有静态成员，必须要继承一个已有的父类或实现一个接口

OuterClass outer = new OuterClass/Interface () {
	@Override//...
};

定义在外部类****成员位置上：
1. 成员内部类
- 与属性、方法在一层级
- 外部类使用内部类的成员，必须先创建内部类对象
- 无修饰符直接写在类中，也是一个类，拥有属性，方法
- 内部类可以使用外部类的成员变量
- 强制使用外部类的属性和方法：
- 外部类名.this.属性名/方法名
1. 静态内部类（被static修饰）
- 使用static修饰的成员内部类
- 内部类中存在静态成员，那么内部类必须是静态的
- 静态方法只存在静态内部类，不存在成员内部类
- 外部类的静态方法直接调用
- 外部类的非静态方法，需要先创建对象

3个修饰符

abstract抽象

没有实现的方法
没有方法体
有抽象方法的类，一定要声明成抽象类
抽象类不能被实例化

static静态

static 不能修饰哪些？

static不能修饰外部类，类的存在就是为了产生对象，而static就是为了不实例化，不产生对象，不过static可以修饰内部类。
既然是共享属性，static就不能修饰局部变量了，主方法和普通方法中都不能用static来修饰变量。

final

一、final关键字可以用来修饰类、方法、变量。

A、修饰类(class)

 1、该类不能被继承。

2、类中的方法不会被覆盖，因此默认都是final的。
3、用途：设计类时，如果该类不需要有子类，不必要被扩展，类的实现细节不允许被改变，那么就设计成final类

B、修饰方法(method)
     1、该方法可以被继承，但是不能被覆盖。
     2、用途：一个类不允许子类覆盖该方法，则用final来修饰
     3、好处：可以防止继承它的子类修改该方法的意义和实现；更为高效，编译器在遇到调用fianal方法转入内嵌机制，提高了执行效率。
     4、注意：父类中的private成员方法不能被子类覆盖，因此，private方法默认是final型的(可以查看编译后的class文件)

C、修饰变量(variable)

 1、用final修饰后变为常量。包括**静态变量、实例变量和局部变量**这三种。

2、特点：可以先声明，不给初值，这种叫做final空白。但是使用前必须被初始化。一旦被赋值，将不能再被改变。

D、修饰参数(arguments)

1、用final修饰参数时，可以读取该参数，但是不能对其作出修改。

二、final关键字不能用来修饰抽象类和接口。

局部变量只能用final修饰

类、属性、方法、局部变量，不希望被继承重写或者改变的时候，前面加final

访问权限修饰符

public谁都能访问，protected子类和同一个包的类可以访问，default同一个包可以访问，private只有类内部方法可以访问。

默认修饰符default，子类可以继承，但是子类不能访问。

this和super的区别？

this代表本类的当前实例
调用本类内部的其他重载的构造方法
访问本类中以及父类中继承的、可见的成员(方法和属性（字段）)
this关键字可单独使用
super用于访问从父类继承的、可见的成员
调用父类的构造方法
访问从父类继承的、可见的成员(方法和属性（字段）)
super关键字不能单独使用

成员变量、局部变量、静态变量区别‍

变量类型	定义位置	作用范围	默认值	在内存中的位置	生命周期
成员变量	类中，方法外部	整个类	具有默认值	位于堆内存	方法进栈而存在，方法出栈而消失
局部变量	方法内部	只能在方法中使用	无默认值（不赋初值报错）	位于栈内存	对象创建而存在，对象被回收而消失
静态变量	方法外部	整个类	具有默认值	位于方法的静态区	随着类的加载而加载，随着类的消失而消失

‍

接口Interface

把一些没有实现的方法，封装到一起，等某个类用时再拿出来
interface接口名
class 类名 implements 接口
接口中有3中方法：

接口中抽象方法，可省略abstract
jdk8以后接口中可以有默认实现方法，但要用default修饰
jdk8以后接口中可以有静态方法static

1.接口interface与抽象类abstract的区别

接口是对动作的抽象，抽象类是对根源的抽象。
当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
一般抽象类会被继承，其子类实现抽象方法
接口可以被多重实现（implements）,抽象类只能被单一继承（extends）
实现（implements） : 一个类实现一个接口的关键字，实现一个接口，必须实现接口中的所有抽象方法。

1）接口不能有构造方法，抽象类可以有。

2）接口不能有方法体，抽象类可以有。

3）接口不能有静态方法，抽象类可以有。

4）接口多继承，抽象类单继承

5）接口--- 实现implement的方式，

抽象类 --- 继承extends的方式，

实现类(普通类、抽象类) ---> 实现接口

6)区别：

抽象类可以有抽象方法，只需要声明，无需实现；抽象方法不能声明为静态的，不能被static、final修饰；
接口里的方法都是抽象方法，但是都只是声明，并没有方法体；
抽象类里面可以变量，变量可以私有化；

接口里没有成员变量(被final修饰为常量)只有常量，不能被私有化，只能是公开的；

抽象类可以有构造方法,接口中不能有构造方法；
抽象类中抽象方法的访问类型可以是public，protected，但接口中抽象方法的访问类型只能是public，并且默认为public abstract（省略则自动默认补全）
抽象类中可以有静态方法，接口中不能有静态方法。

1.默认的修饰符不同:

类当中的默认的修饰符是访问权限修饰符 default

接口中的方法的默认修饰符public abstract

接口中的属性的默认修饰符public static final

2.成员不同:

类中可以存在所有的类的成员

接口中没有构造代码块、构造方法、静态代码块

3.继承规则不同:

抽象类遵循类的继承规则- - 单继承

接口遵循接口的继承规则- - 多实现

4.使用方式:

抽象类需要通过继承的方式，使用普通子类完成实例化操作(普通子类只能继承一个抽象类)

接口需要通过实现的方式，使用普通的实现类完成接口的使用(普通实现类可以同事实现多个接口)

一个类可以实现多个接口，但最多只能继承一个抽象类
一个类实现接口的话要实现接口的所有方法，而抽象类不一定
接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象
‍

联系：

都是引用数据类型
都无法独立实例化

表面看,接口是一种特殊的抽象类,但类是类,接口是接口,是并列的关系，

设计层面看，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

‍

构造器Constrauctor

方法名和类型相同

没有返回值

创建对象时，系统自动调用该类的构造器来完成对对象的初始化

‍

toString方法

默认返回：全类名 + @ + 哈希值的16进制

子类往往重写toString方法，用于返回对象的属性信息

this

当前对象

谁调用就是谁

super

代表父类的引用，用于访问父类的属性，方法，构造器

‍

Object

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象
（包括数组）都实现这个类的方法
A. Object是所有类的直接父类或者是间接父类
B. 所有对象都可以使用Object提供的方法

toString

返回该对象的字符串表示

getClass() 当前对象的class对象

getName() 获取当前对象的类名

getClass().getName() 获取类的完整的包名加上类名

hashCode()根据内存地址生成十进制整数hash值

Integer.toHexString() 用十六进制形式表示

快捷键alt+insert

equals和==

equals()用来比较两个对象的地址值是否相同

equals()只能用来比较引用数据类型

equals默认比较的是两个对象的地址值值是否相同

equals没有重写前比较的是对象的地址值，重写后比较的是对象的属性

== 既可以比较引用数据类型，也可以比较基本数据类型

== 比较基本数据类型的具体值，比较引用数据类型的地址值

String

String 类代表字符串

字符串字面值现在堆内存中字符串常量池中查找，是否有相同字符串，如果有，不开辟空间，没有才开辟

new String（）都会在堆内存中开辟空间

字符串是常量使用final来进行修饰它们的值在创建之后不能更改不能改变字符地址值可以改变内容

因为 String 对象是不可变的，所以可以共享

字符串的底层是以字节数组来进行存储 byte[]

字符串字面值 "abc" 是存在堆内存中字符串常量池 new String() 都是在堆内存中开辟空间

方法名称	方法描述
public boolean contains(CharSequence s)	是否包含此字符串
public boolean equals(Object anObject)	判断两个字符串内容是否相同
public boolean equalsIgnoreCase(String anotherString)	判断两个字符串内容是否相同(不考虑大小写)
public boolean startsWith(String prefix)	测试此字符串是否以指定的前缀开始
public boolean endsWith(String suffix)	测试此字符串是否以指定的后缀结束
public boolean isEmpty()	当且仅当 length() 为 0 时返回 true
public int length()	返回此字符串的长度

方法名称	方法描述
public char charAt(int index)	返回指定索引处的 char 值
public int indexOf(String str)	返回指定子字符串在此字符串中第一次出现处的索引
public int indexOf(String str, int fromIndex)	返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
public int lastIndexOf(String str)	返回指定子字符串在此字符串中最右边出现处的索引
public int lastIndexOf(String str, int fromIndex)	返回指定子字符串在此字符串中最后一次出现处的索引
public String substring(int beginIndex)	从指定索引处的字符开始截取，直到此字符串末尾(包头不尾部)

方法名称	方法描述
public String concat(String str)	将指定字符串连接到此字符串的结尾(+)
public byte[] getBytes()	将字符串转换为字节数组
public char[] toCharArray()	将字符串转换为字符数组
public String toLowerCase()	将字符转换为小写
public String toUpperCase()	将字符转换为大写
public String trim()	忽略前导空白和尾部空白
public String[] split(String regex)	根据指定的字符拆分
public String replaceAll(String regex, String replacement)	替换字符串指定内容

StringBuffer 和StringBuilder

1.概念：
   A.线程安全的可变字符序列 类似于 String 的字符串缓冲区
   B.通过某些方法调用可以改变该序列的长度和内容
   C.StringBuffer 上的主要操作是 append 和 insert 方法
2.StringBuffer与String比较
   String 是不可变的字符序列   StringBuffer是一个可变的字符序列
   String 效率比较低          StringBuffer效率比较高
3.StringBuffer与StringBuilder
   A. 版本不一致   StringBuffer 1.0   StringBuilder 1.5
   B. 线程安全    StringBuffer(安全)  StringBuilder(不安全)
   C. 效率       StringBuffer(效率低) StringBuilder(效率高)

常用构造方法

构造方法名称	构造方法描述
public StringBuffer()	实例化StringBuffer 初始容量为 16 个字符
public StringBuffer(int capacity)	实例化StringBuffer 具有指定初始容量的字符串缓冲区
public StringBuffer(String str)	将字符串转换为StringBuffer,字符串的初始容量为 16 加上字符串参数的长度

常用的方法

方法名称	方法描述
public StringBuffer append(String str)	向末尾追加内容
public StringBuffer insert(int offset, String str)	在指定的位置追加
public StringBuffer deleteCharAt(int index)	根据索引来进行删除
public StringBuffer delete(int start, int end)	删除指定区间内容
public StringBuffer reverse()	控制反转
public int capacity()	获取初始化容量

StringBuffer与String之间的相互转换

A.将String 转换为StringBuffer
   a.public StringBuffer(String str) 通过构造方法
   b.new StringBuffer().append(str) 通过调用方法
B.将StringBuffer转换为String
   a.public String(StringBuffer buffer) 通过构造方法
   b.public String toString() 通过调用toString()方法

包装类

简介

1.概念:将基本数据类型封装成类 可以访问其属性与方法  功能更加强大
2.罗列
3.特点:
    A.大部分都是将基本数据类型的首字母变为大写
    B.int Integer与char Character 包装类比较特殊
    C.在实际开发中使用比较多的包装类是Integer

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
boolean	Boolean
double	Double
float	Float

Integer

简介

A.Integer 类在对象中包装了一个基本类型 int 的值 Integer 类型的对象包含一个 int 类型的字段
B.该类提供了多个方法，能在 int 类型和 String 类型之间互相转换
C.还提供了处理 int 类型时非常有用的其他一些常量和方法

常量

常量名称	常量描述
public static final int MAX_VALUE	它表示 int 类型能够表示的最大值
public static final int MIN_VALUE	它表示 int 类型能够表示的最小值
public static final int SIZE	表示 int 值的比特位数
public static final Class TYPE	表示基本类型 int 的 Class 实例

构造方法

构造方法名称	构造方法描述
public Integer(int value)	将int(基本数据类型)类型包装成Integer(引用数据类型)
public Integer(String s)	将String包装成Integer类型

常用方法

方法名称	方法描述
public static int parseInt(String s)	将字符串转换为int类型
public static String toBinaryString(int i)	以二进制返回一个整数参数的字符串表示形式
public static String toOctalString(int i)	以八进制返回一个整数参数的字符串表示形式
public static String toHexString(int i)	以十六进制返回一个整数参数的字符串表示形式
public static Integer valueOf(int i 或者String i)	将int类型或者是String类型包装成Integer类型
public int xxxValue()	xxx==>表示各种基本数据类型(将Integer转换为xxx类型)

自动拆箱与自动装箱

1.装箱:将基本数据类型包装成包装类(打包快递)
2.拆箱:将包装类拆成基本数据类型(拆快递)
3.在jdk1.5之后 可以实现自动拆箱与自动装箱
4.自动装箱:将基本数据类型(基本数据类型==>引用数据类型)的数据赋值给包装类的引用
5.自动拆箱:将包装类(引用数据类型==>基本数据类型)的引用赋值给基本数据类型的变量

System

7.1简介

A.System 类包含一些有用的类字段和方法。它不能被实例化
B.System 类提供的设施中，有标准输入、标准输出和错误输出流

7.2 常用常量

方法名称	方法描述
public static final PrintStream err	标准”错误输出流
public static final InputStream in	“标准”输入流
public static final PrintStream out	标准”输出流

7.3 常用方法

方法的名称	方法的描述
public static long currentTimeMillis()	获取当前系统的毫秒值
public static void exit(int status)	终止当前正在运行的 Java 虚拟机(非 0 的状态码表示异常终止)
public static void gc()	运行垃圾回收器

八 Date

8.1 简介

1.类 Date 表示特定的瞬间，精确到毫秒。 时间类

8.2 构造方法

构造方法名称	构造方法描述
public Date()	表示分配它的时间（精确到毫秒）实例化Date对象
public Date(long date)	1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒

8.3 常用方法

方法名称	方法描述
public long getTime()	自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
public void setTime(long time)	设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点

九 Calendar

9.1 简介

A.Calendar 类是一个抽象类，
B.它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法
C.常量
    public static final int YEAR 年
    public static final int MONTH 月
    public static final int DAY_OF_MONTH 日
    public static final int HOUR 小时
    public static final int MINUTE 分钟
    public static final int SECOND 秒钟

9.2 常用方法

方法名称	方法描述
public static Calendar getInstance()	使用默认时区和语言环境获得一个日历
public int get(int field)	返回给定日历字段的值
public void set(int field, int value)	将给定的日历字段设置为给定值
public final void setTime(Date date)	使用给定的 Date 设置此 Calendar 的时间
public final Date getTime()	返回一个表示此 Calendar 时间值
public abstract void add(int field, int amount)	根据日历的规则，为给定的日历字段添加或减去指定的时间量

十 SimpleDateFormat

10.1 简介

1.SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类 时间格式化工具类
2.构造方法
   public SimpleDateFormat(String pattern)  参数:描述日期和时间格式的模式 
3.常用的方法
   public Date parse(String source) ==>将指定的字符串时间转换为Date对象
   public final String format(Date date)==>将Date对象格式化为指定的时间

Scanner

A.一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器==> 扫描器
B.Scanner 的多线程使用是不安全的

Arrays

此类包含用来操作数组（比如排序和搜索）的各种方法数组操作类

BigDecimal

A.不可变的、任意精度的有符号十进制数 ==>大的数据类型

异常

开发中异常:程序在编译期间或者运行期间发生错误
A.程序在编译期间发生错误
B.程序在运行期间发生错误
C.项目中实际的需求与代码执行的顺序不匹配的时候

jvm处理异常的方式

A.某段代码发生了异常
B.将异常的信息封装到 Throwable中
C.将异常抛给调用
D.一层一层往上抛
E.如果调用者都不处理异常就由jvm来处理异常
F.jvm处理异常
a.在控制台打印异常信息(堆栈信息) b.终止程序的运行

异常处理

ctrl + shift + t

捕获-try-catch

1.语法：
try{
可能发生异常的代码
}catch(异常类型声明) {
发生异常处理方式
}
2.单词翻译: try ==>尝试 catch 抓取捕捉
3.解释:
A.try中的代码 ==>try中是可能产生异常的代码
B.catch小括号后是异常类型的声明异常类型必须是 Throwable的子类
C.catch大括号中发生异常的处理方式 a.收集异常的信息(日志信息) b.编写代码处理异常
4.执行流程
A.执行try中的代码
B.如果不发生异常不会执行catch中代码正常执行下面的代码
C.如果发生异常
a.如果发生的异常与声明的异常可以匹配则执行catch中代码再正常执行下面代码
b.如果发生的异常与声明的异常不可以匹配则由jvm来处理异常: a.打印堆栈信息 b.终止程序
注意点
a.匹配:发生的异常是声明异常的本身或者是其子类

捕获-try-catch-catch

1.语法:
try{
可能发生异常代码
}catch(异常类型声明) {
发生异常处理方式
}catch(异常类型声明){
发生异常处理方式
}
2.执行流程
A.执行try中代码
B.如果不发生异常则执行后面的代码
C.如果发生异常
a.发生的异常依次与catch中异常类型进行匹配如果可以匹配则执行对应catch中代码
b.发生的异常与catch异常类型不匹配则由 jvm来处理异常
1)打印堆栈信息 2)终止程序
3.说明:
A.多个异常类型声明的时候是由小的范围到大的范围
B.声明异常类型的范围越小越好容易帮助解决问题
C.在jdk1.7之后声明多个异常可以使用|来连接多个异常

捕获-try-catch-finally

1.语法:
try{
可能发生异常代码
}catch(异常类型的声明){
异常处理方式
} finally{
最后执行的代码
}
2.单词翻译:finally 最终最后
3.执行流程
A.执行try中代码如果没有发生异常执行finally中代码再执行下面代码
B.如果发生了异常
a.如果发生的异常与声明的异常可以匹配执行 catch中代码再执行finally中代码
b.如果发生的异常与声明的异常不可以匹配执行finally中代码
异常由jvm来处理 1)打印堆栈信息 2)终止程序
4.说明
A.不管是否发生异常都是执行finally中代码
B.遇到return 关键字会先执行finally中代码再执行return
C.杀死jvmjava虚拟机才不执行finally中代码
D.释放资源

捕获- try- finally

1.语法:
try{
可能发生异常代码

}finally{
最终执行代码
}
2.执行流程
A.执行try中的代码
B.执行finally代码
3.说明
A.主要是将try与finally中的代码进行分离代码清晰结构度高
B. 发生异常还是由jvm来进行处理

Throws

1.Throws 声明异常
2.使用场景:在方法中方法中的代码可能发生异常但是不想自身来进行处理就可以声明异常抛出由调用者处理
3.语法:
访问修饰符返回值类型方法名称(参数列表) throws 异常类型{
方法体
return 返回值
}
4.说明
A.声明异常的范围越小越好
B.如果声明的异常是运行时异常本身或者是其子类的时候调用者可能不进行处理
C.如果声明的异常不是运行时异常本身或者是其子类的时候调用必修处理

Throw

1.Throw 抛出异常
2.语法:
访问修饰符返回值类型方法名称(参数列表){
throw new 异常类型()
}
3.说明
A.抛出的异常是运行时异常以及其子类的时候调用者不需要进行处理
B.抛出的异常不是运行时异常以及其子类的时候调用者必须进行处理
C.在一个作用域中只能抛出一个异常
D.Throw 一般与Throws搭配使用

Throw与 Throws 比较

Throw	Throws
抛出异常	声明异常
在方法体中	在方法参数列表后
作用域下只能抛出一个异常	声明多个异常
异常确实存在,确实可能发生这个异常	异常不一定存在 ,异常并不一定会发生

Throwable

所有异常类的直接父类或者是间接父类
2.自定义异常
A.定义一个类继承 Execption
B.调用父类构造方法

异常Throwable(类)

是Java语言中所有错误(errors)和异常(exceptions)的父类

Error错误

无法通过处理，只能事先避免
- 内存溢出
- 系统崩溃
Exception异常

程序员可以通过代码纠正
- 编译时期异常checked
  
  eg.语法不规范
- 运行时期异常runtme
  
  eg.角标越界，空指针

异常处理

throw抛出

⽤在⽅法内，⽤来抛出⼀个异常对象，将这个异常对象传递到调⽤者处，并结束当前⽅法的执⾏。

try-catch捕获

try执行可能产生异常的代码

catch捕获异常

throws声明

将问题标识出来，报告给调⽤者。表示当前⽅法不处理异常,⽽是提醒该⽅法的调⽤者来处理异常(抛出异常)。

finally

无论是否发生异常，都会执行

posted @ 2023-01-17 21:27 Ritchie^._.^ 阅读(101) 评论(0) 收藏举报

刷新页面返回顶部

Ritchie^._.^

面向对象编程三大特征