Java面向对象学习笔记_对于任何非空的x,y对象-CSDN博客

本文链接：https://blog.csdn.net/weixin_43541852/article/details/108435190

一、继承

概述

继承是Java中面向对象编程技术的一块基石，因为他允许创建分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

格式

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

示例：
class Person{
…
}
class Studet extends Preson{
}

继承的限制

Java中只有单继承（一父一子），多重继承（爷-爹-儿），没有多继承（一个儿子好几个爹）。

子类实例化内存分析

class Person{
	private String name;
	private int age;
	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public void say(){
		System.out.println("我叫"+name+"，我今年"+age+"岁了");
	}
}

class Student extends Person{
	private String name;
	private int age;
	private String school;
	...//省略一些构造方法
	...//省略一些get和set方法
	public void say(){
		System.out.println("我叫"+name+"，我今年"+age+"岁了，我来自"+school+"学校");
	}

在这里插入图片描述
1.创建一个子类对象时，先创建一个父类对象，父类对象完全创建好了，再开始创建子类对象
2.子类对象里有个super属性，它指向父类对象，当对子类对象进行操作时，如果子类对象里没有相关方法或属性，会通过super来对父类对象进行操作，即name和age实际上设置的是Person对象
3.子类只能操作权限修饰符允许范围内的属性和方法（public/protected）

super关键字

1.通过super，可以访问父类的构造方法
调用super构造方法的代码，必须写在子类构造方法的第一行。（super和this不能同时调用）
2.通过super，可以访问父类的属性
3.通过super，可以访问父类的方法

final关键字

final用于修饰属性、变量
修饰后就变成了常量，无法对其再次进行赋值
final修饰的局部变量，只能赋值一次（可以先声明后赋值）
final修饰的是成员属性，必须在声明时赋值
全局常量（public static final）
常量的命名规范：
由1个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写
例如：SQL_INSERT
final用于修饰类
final修饰的类，不可以被继承
final用于修饰方法
final修饰的方法，不能被子类重写

二、抽象类

概念

抽象类必须使用abstract class声明
一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中。
格式：
abstract class 类名{ // 抽象类

}

抽象方法

只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关键字声明。
格式：

abstract class 类名{ // 抽象类 
	public abstract void 方法名() ; // 抽象方法，只声明而未实现 
}

抽象类使用原则

在抽象类的使用中有几个原则：

抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全部抽象方法。

常见问题：

抽象类能否使用final声明？
不能，因为final属修饰的类是不能有子类的，而抽象类必须有子类才有意义，所以不能。
抽象类能否有构造方法？
能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。（抽象类不能被我们开发者创建，但是JVM可以自行创建）

三、接口

概念

如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。
定义格式：

interface 接口名称{
	全局常量；
	抽象方法；
}

面向接口编程思想

这种思想是接口定义（规范，约束）与实现（名实分离的原则）的分离。
优点：

降低程序的耦合性
易于程序的扩展
有利于程序的维护

全局常量和抽象方法的简写

因为接口本身都是由全局常量和抽象方法组成，所以接口中的成员定义可以简写：

全局常量编写时，可以省略public static final 关键字，例如：
public static final String INFO = “内容” ;
简写后：
String INFO = “内容” ;
抽象方法编写时，可以省略 public abstract 关键字，例如：
public abstract void print() ;
简写后：
void print() ;

接口的实现implements

接口可以多实现：
格式：

class 子类 implements 父接口1,父接口2...{

}

以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：

class 子类 extends 父类 implements 父接口1,父接口2...{

}

接口的继承

接口因为都是抽象部分，不存在具体的实现，所以允许多继承,例如：

interface C extends A,B{

}

注意：如果一个接口要想使用，必须依靠子类。子类（如果不是抽象类的话）要实现接口中的所有抽象方法。

接口和抽象类的区别

抽象类要被子类继承，接口要被类实现。
接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
抽象类使用继承来使用，无法多继承。接口使用实现来使用，可以多实现
抽象类中可以包含static方法，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）
接口不能有构造方法，但是抽象类可以有

四、多态

概念

多态：就是对象的多种表现形式，（多种体现形态）
多态的体现：对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态，对象多态性就从此而来。
ps：方法的重载和重写也是多态的一种，不过是方法的多态（相同方法名的多种形态）。
重载：一个类中方法的多态性体现
重写：子父类中方法的多态性体现。

多态的使用：对象的类型转换

类似于基本数据类型的转换：

向上转型：将子类实例变为父类实例
格式：父类父类对象 = 子类实例；
向下转型：将父类实例变为子类实例
格式：子类子类对象 = （子类）父类实例；

五、Object类

概念：

Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类。
例如我们定义一个类：

public class Person{ 
}

其实它被使用时是这样的：

public class Person extends Object{
}

Object的多态

使用Object可以接收任意的引用数据类型

toString

建议重写Object中的toString方法。此方法的作用：返回对象的字符串表示形式。
（用来描述对象的信息，具体使用API查看）
Object的toString方法，返回对象的内存地址
在这里插入图片描述

equals

建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否“等于”此对象。（没有特殊需求可用快捷键shift+alt+s生成）
Object的equals方法：实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和y ，当且仅当 x和y引用同一对象（ x == y具有值true ）时，此方法返回true 。

equals方法重写时的五个特性：

自反性：对于任何非空的参考值x ， x.equals(x)应该返回true 。
对称性：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。
传递性：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true和y.equals(z)回报true ，然后 x.equals(z)应该返回true 。
一致性：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象上的equals比较中使用的信息。
非空性：对于任何非空的参考值x ， x.equals(null)应该返回false 。

在这里插入图片描述

六、包装类

概述

在Java中有一个设计的原则“一切皆对象”，那么这样一来Java中的一些基本的数据类型，就完全不符合于这种设计思想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了八种基本数据类型的包装类。

```
 	int         		Integer
```
```
 char				Character
```
```
 float				Float
```
```
 double				Double
```
```
 boolean				Boolean
```
```
 byte				Byte
```
```
 short				Short
```
```
 long				Long
```

以上的八种包装类，可以将基本数据类型按照类的形式进行操作。
但是，以上的八种包装类也是分为两种大的类型的：

Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。（快捷键Ctrl+T可以查看类的结构）
Object：Character、Boolean都是Object的直接子类。

（包装类的好处：数据可以作为对象被传进方法中；类的可操作性更高，比如int i = Integer.parseInt(“100”)可以直接将字符串类型100转换成int类型100）

装箱和拆箱操作

以下以Integer和Float为例进行操作：
将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。
将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作。

在这里插入图片描述
因为所有的数值型的包装类都是Number的子类，Number的类中定义了如下的操作方法，以下的全部方法都是进行拆箱的操作。

```
 	方法 															描述 
```

 public byte byteValue() 								用于Byte->byte

 public abstract double doubleValue() 			用于Double->double

 public abstract float flfloatValue() 				用于Float->flfloat

 	public abstract int intValue() 						用于Integer->int

 public abstract long longValue() 					用于Long->long

 public short shortValue() 							用于Short->short

装箱操作：
在JDK1.4之前，如果要想装箱，直接使用各个包装类的构造方法即可，例如：

int temp = 10 ; // 基本数据类型 
Integer x = new Integer(temp) ; // 将基本数据类型变为包装类

在JDK1.5，Java新增了自动装箱和自动拆箱，而且可以直接通过包装类进行四则运算和自增自建操作。例如：

Float f = 10.3f ; // 自动装箱 
float x = f ; // 自动拆箱 
System.out.println(f * f) ; // 直接利用包装类完成 
System.out.println(x * x) ; // 直接利用包装类完成