java面向对象学习

文章目录

• 1.类和对象
• • 1.1 类的定义
  • 1.2 对象的使用
  • 1.3 成员变量的默认值
  • 1.4 成员变量和局部变量区别
• 2.封装
• • 2.1 封装的步骤
  • 2.2 private关键字
  • 2.3 this关键字
  • 2.4 构造方法
  • 2.5 static关键字
  • 2.6 静态代码块
• 3.继承
• • 3.1 继承的格式
  • 3.2 继承后的特点——成员变量
  • 3.3 继承后的特点——成员方法
  • 3.4 继承后的特点——构造方法
  • 3.5 继承的特点
• 4.抽象类
• • 4.2 抽象方法
  • 4.3 抽象的使用
• 5.接口
• • 5.1接口定义格式
  • 5.2 接口的实现
  • 5.3 接口的多实现
  • 5.4 优先级的问题
  • 5.5 接口的多继承
  • 5.6 其他成员特点
• 6.多态
• • 6.1 多态格式：
  • 6.2 多态的好处：
  • 6.3 引用类型转换
  • 6.4 转型的异常
• 7. final关键字
• 8.权限修饰符
• 9.内部类
• • 9.1 内部类
  • 9.2 匿名内部类

1.类和对象 1.1 类的定义

类的定义格式：
public class ClassName {
	//成员变量
	//成员方法
}

1.2 对象的使用

创建对象：
		类名 对象名 = new 类名();

使用对象访问类中的成员:
		对象名.成员变量；
		对象名.成员方法()；

1.3 成员变量的默认值

1.4 成员变量和局部变量区别

2.封装 2.1 封装的步骤

1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

2.2 private关键字

1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。

2.3 this关键字

区分成员变量和局部变量

this使用格式：
	this.成员变量名；

2.4 构造方法

构造方法的定义格式：
修饰符 构造方法名(参数列表){
	// 方法体
}

注意事项：
1. 如果你不提供构造方法，系统会给出无参数构造方法。
2. 如果你提供了构造方法，系统将不再提供无参数构造方法。
3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

2.5 static关键字

1.static可以修饰成员变量，类变量
2.static可以修饰方法，静态方法
3.static可以修饰代码块，静态代码块


调用格式：
	类名.类变量名；
	类名.静态方法名(参数)；

静态方法调用的注意事项： 
	1.静态方法可以直接访问类变量和静态方法。
	2.静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。 
	3.静态方法中，不能使用this关键字。
	
	小贴士：静态方法只能访问静态成员。	

2.6 静态代码块

静态代码块：定义在成员位置，使用static修饰的代码块{ }。 
	位置：类中方法外。 
	执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
	
格式：
	public class ClassName{
		 static { 
		 	// 执行语句 
		 } 
	 }

作用：给类变量进行初始化赋值。

3.继承 3.1 继承的格式

class 父类 {
	...
}

class 子类 extends 父类 {
	...
}

3.2 继承后的特点——成员变量

成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的

成员变量重名

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，
需要使用 super 关键字，修饰父类成员变量

使用格式：
	super.父类成员变量名

3.3 继承后的特点——成员方法

成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对

成员方法重名——重写(Override)

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同）

使用格式：
	super.父类成员方法

注意事项
	1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
	2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

3.4 继承后的特点——构造方法

1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

3.5 继承的特点

1. Java只支持单继承，不支持多继承。
	//一个类只能有一个父类，不可以有多个父类。
	class C extends A{} //ok
	class C extends A，B... //error

2. Java支持多层继承(继承体系)。
	class A{}
	class B extends A{}
	class C extends B{}
	
3.顶层父类是Object类。所有的类默认继承Object，作为父类。

4.抽象类

抽象类：包含抽象方法的类

4.2 抽象方法

定义格式：
	修饰符 abstract 返回值类型 方法名 (参数列表)；
	public abstract void run()；

4.3 抽象的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。

注意事项:
1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

5.接口 5.1接口定义格式

public interface 接口名称 {
	// 抽象方法
	// 默认方法
	// 静态方法
	// 私有方法
}

接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法
（JDK 9）。

5.2 接口的实现

class 类名 implements 接口名 {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【可选】
}

5.3 接口的多实现

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【不重名时可选】
}

5.4 优先级的问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

5.5 接口的多继承

interface D extends A,B{
	@Override
	public default void method() {
		System.out.println("DDDDDDDDDDDDDD");
	}
}

5.6 其他成员特点

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。

6.多态 6.1 多态格式：

父类类型 变量名 = new 子类对象；
变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

6.2 多态的好处：

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用

6.3 引用类型转换

父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();

子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

6.4 转型的异常

public class Test {
	public static void main(String[] args) {
			// 向上转型
			Animal a = new Cat();
			a.eat(); // 调用的是 Cat 的 eat
			// 向下转型
			if (a instanceof Cat){
				Cat c = (Cat)a;
				c.catchMouse(); // 调用的是 Cat 的 catchMouse
			} else if (a instanceof Dog){
				Dog d = (Dog)a;
				d.watchHouse(); // 调用的是 Dog 的 watchHouse
			}
   }
}

7. final关键字

类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。

修饰类

final class 类名 {
}

修饰方法

修饰符 final 返回值类型 方法名(参数列表){
	//方法体
}

修饰变量

在这里插入代码片

8.权限修饰符

public：公共的。
protected：受保护的
default：默认的
private：私有的

9.内部类 9.1 内部类

成员内部类
成员内部类 ：定义在类中方法外的类。

class 外部类 {
	class 内部类{
	}
}

访问特点

内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。'

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

9.2 匿名内部类

new 父类名或者接口名(){
	// 方法重写
	@Override
	public void method() {
		// 执行语句
	}
};