JAVA学习笔记（高级篇）【面向对象】

继承

1.概念
面向对象三大特征之一（封装，继承，多态）。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。
2.格式
public class 子类名 extend 父类名 { }

	public class Zi extends Fu{}
	//Fu：是父类，也被称为基类，超类
	//Zi：是子类，也被称为派生类

子类可以有父类的内容，也可以有自己特有的内容。
3.好处和弊端
好处：

• 提高了代码的复用性（多个类相同的成员可以放到同一个类中）
• 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

弊端：
继承让类与类之间产生了关系,类的耦合性增强了,当父类发生变化时子实现也不得不跟着变化,削弱了子类的独立性
4.继承中变量的访问特点
在子类方法中访问一个变量

• 子类局部范围找
• 子类成员范围找
• 父类成员范围找
• 如果都没有就报错(不考虑父亲的父亲…)

super

super关键字的用法和this关键字的用法相似

• this：代表本类对象的引用
• super：代表父类存储空间的标识(可以理解为父类对象引用)

关键字	访问成员变量	访问构造方法	访问成员方法
this	this.成员变量访问本类成员变量	this(...)访问本类构造方法	this.成员方法()访问本类成员方法
super	super.成员变量访问父类成员变量	super(...)访问父类构造方法	super.成员方法(...)访问父类成员方法

继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法。

• 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
• 每一个子类构造方法的第一条语句默认都是: super()

若父类中没有无参构造方法，只有带参构造方法

• 通过使用super关键字去显示的调用父类的带参构造方法
• 在父类中自己提供一个无参构造方法

继承中成员方法的访问特点

• 子类成员范围找
• 父类成员范围找.
• 如果都没有就报错(不考虑父亲的父亲…)

方法重写

概念
子类中出现了和父类中一模一样的方法声明
应用
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

@Override

一个注解，帮助检查方法重写的正确性

方法重写注意事项

• 私有方法不能被重写(父类私有成员子类是不能继承的)
• 子类方法访问权限不能更低(public>默认>私有)

JAVA继承的注意事项

• JAVA中类只支持单继承，不支持多继承
• JAVA中类支持多层继承

包

其实就是文件夹，作用就是对类进行分类管理

导包

import+包名。

权限修饰符

修饰符	同一个类中	同一个包中子类、无关类	不同包的子类	不同包的无关类
private	√
默认（直接void）	√	√
protected	√	√	√
public	√	√	√	√

状态修饰符

1.final
可以修饰成员方法，成员变量，类

	public final void method(){
	
	}
	public final int age = 20;
	public final class Fu{

	}

修饰方法: 表明该方法是最终方法，不能被重写
修饰变量: 表明该变量是常量,不能再次被赋值
修饰类: 表明该类是最终类,不能被继承

static

1.概念
static关键字是静态的意思，可以修饰成员方法,成员变量
被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
可以通过类名调用，当然，也可以通过对象名调用
推荐使用类名调用
2.访问特点
非静态的成员方法

• 能访问静态的成员变量
• 能访问非静态的成员变量
• 能访问静态的成员方法
• 能访问非静态的成员方法

静态的成员方法

• 能访问静态的成员变量
• 能访问静态的成员方法
  总结一句话：静态成员方法只能访问静态成员

多态

1.概念
同一对象，在不同时刻表现出来的不同形态
2.多态的前提和体现

• 有继承/实现关系
• 有方法重写
• 有父类引用指向子类对象

	Animals cat = new Cat();

3.多态访问成员特点

• 成员变量：编译看左边，执行看左边。
• 成员方法：编译看左边，执行看右边

因为成员方法有重写，成员变量没有

4.多态的好处和弊端
多态的好处：提高了程序的扩展性，具体体现在定义方法的时候，使用父类型作为参数,将来在使用的时候，使用具体的子类型参与操作
多态的弊端：不能使用子类的特有功能
5.多态中的转型
向上转型，即为正常多态使用。
向下转型，父类引用转为子类对象

	Animal a =new Cat();
	Cat c = (Cat)a;//强制类型转换

抽象类

1.概念
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类
2.特点

• 抽象类和抽象方法必须使用abstract关键字修饰
  public abstract class名{}
public abstract void eat();
  抽象类中不一定有抽象方法,有抽象方法的类一 定是抽象类
• 抽象类不能实例化
  抽象类如何实例化呢?参照多态的方式，通过子类对象实例化，这叫抽象类多态
• 抽象类的子类
  要么重写抽象类中的所有抽象方法
  要么是抽象类
  3.成员特点
• 成员变量：可以是变量也可以是常量。
• 构造方法：有构造方法，但是不能实例化。用于子类访问父类数据的初始化。
• 成员方法： 可以有抽象方法来限定子类必须完成某些动作

接口

用关键字interface修饰

	public interface 接口名{}

类实现接口用implements表示

	public class 类名 implements 接口名{}

接口不能实例化，参照多态的方式，通过实现类对象实例化，叫接口多态。

类和接口的关系

• 类和类，只能单继承，但是可以多层继承
• 类和接口，可以单实现也可以实现，还可以在继承一个类的同时实现多个接口。
• 接口和接口，可以单继承，也可以多继承

抽象类和接口的区别

抽象类是对事物的抽象，接口是对行为的抽象。

类名作为形参和返回值

• 方法的形参是类名，其实需要返回该类的对象
• 方法的返回值是类名，其实返回的是该类的对象

抽象类名作为形参和返回值

• 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
• 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

接口名作为形参和返回值

• 方法的形参是接口名，其实需要的是该接口的实现类对象
• 方法的返回值是接口名，其实返回的是该接口的实现类对象

内部类

格式

	public class 类名{
		public class 类名{
		}
	}

特点

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

成员内部类
格式：外部类名.内部类名 对象名=外部类对象.内部类对象；

	Outer.Inner oi = new Outer().new Inner();
	//
	public class 类名{
		public class 类名{
			public void show{
				System.out.println();
				}
			}
		}
	}

案例

	//外部类
	public class Outer {
	private String name = "小明";
	public class Inner{
		private String name = "小红";
		public void show1() {
			System.out.println(Outer.this.name);
		}
		public void show2() {
			System.out.println(this.name);
		}
	}
}
//测试类
 public static void main(String[] args) {
	       Outer.Inner oi = new Outer().new Inner();
	       oi.show1();
	       oi.show2();
	    }
	    //小明
	    //小红

局部内部类

	public class 类名{
		public class 类名{
			class Inner{
			public void show{
				System.out.println();
				}
			}
			Inner i = new Inner;
			i.show();
		}
	}

在方法内部创建对象并使用
匿名内部类
格式

	new 类名或者接口名(){
		重写方法;
	};
	new Inter(){
		public void show(){
		}
	};

本质：是一个继承了该类或者实现了该接口的子类匿名对象
对象就可以调用方法。

	new Inter(){
		@Override
		public void show(){
		}
	}.show();
	//
	Inter i = new Inter(){
		@Override
		public void show(){
		}
	};
	i.show();

案例

public static void main(String[] args) {
		Outer.method().show();	
	}
}

interface Inner{
	void show();
}

class Outer {
//补齐代码
}

	 public static Inner method() {
	return new Inner(){
		@Override
		void show(){
		System.out.println("123");
		};
	}

Math

包含执行基本数字运算的方法，查看帮助文档，若其为静态，通过类名直接调用。

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)	按照四舍五入返回最接近参数的int
public static int max(int a,int b)	返回两个int值中的较大值
public static int min(int a,int b)	返回两个int值中的较小值
public static double pow(double a,double b)	返回a的b次幂的值
public static double random()	返回值为double的正值，[0.0,1.0)

	Math.abs();

System

包含了几个有用的类字段和方法，它不能被实例化。
System.exit()：终止当前运行的JAVA虚拟机，非零状态码表示异常终止

Obiect

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类
重写toString()方法

Arrays

包含用于操作数组的各种方法

方法名	说明
public static String toString(int[]a)	返回指定数组的内容的字符串表示形式
public static void sort(int[]a)	按照数字顺序排列指定数组

工具类设计思想：

• 构造方法用private修饰
• 成员用public ststic修饰

基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

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

Integer

方法名	说明
public static Integer valueOf(int i)	返回表示指定的int值得Integer实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer对象String

int和String的相互转换

1.int转换为String
public static String valueOf(int i):返回int参数的字符串表示形式。该方法是String类中的方法
2.String转换为int
public static int parseInt(String s):将字符串解析为int类型。该方法是Integer类中的方法。

装箱拆箱

• 装箱：把基本数据类型转换为对应的包装类类型
• 拆箱：把包装类类型转换为对应的基本数据类型

	Integer i =100;//自动装箱
	i += 200;//i+200自动拆箱，i = i+200自动装箱

在使用包装类类型的时候，最好先判断是否为null
只要是对象，在使用前就必须进行不为null的判断

日期类

1.Date类
代表了一个特定的时间，精确到毫秒

方法名	说明
public Date()	分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)	分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
public long getTime()	获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值

2.SimpleDateFormat类
SimpleDateFormat是一个具体的类， 用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析
构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat, 使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

1.格式化（从Date到String）
public final String format(Date date)：将日期格式化成日期/时间字符串
2.解析（从String到Date）
public Date parse(Strig source)：从给定字符串的开始解析文本以生成日期

	Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat();
		String s = sdf.format(d);
		System.out.println(s);
		//2021/5/22 下午9:45

常用的模式字母及对应关系如下：

• y 年
• M 月
• d 日
• H 时
• m 分
• s 秒

格式：
SimpleDateFormat sddf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
3.Calendar类
创建显示当前日期

	Calendar c = Calendar.getInstance();//默认是当前日期

创建一个指定日期

	//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 , 12);

把对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算

c1.add(Calendar.DATE, 10);

获得信息

	Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);

异常

1.异常体系

Error：严重问题，不需要处理
Exception：称为异常类，它表示程序本身可以处理的问题

• RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码
• 非RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了

2.异常处理

• try…catch…
  格式：

  	try{
  	可能出现异常的代码;
  	}catch (异常类名 变量名){
  	异常的处理代码;	
  	}
  

  样例

  public class ExcepTest{
  
  public static void main(String args[]){
    try{
       int a[] = new int[2];
       System.out.println("Access element three :" + a[3]);
    }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("Exception thrown  :" + e);
    }
    System.out.println("Out of the block");
  }
  

• throws
  格式：

  throws 异常类名
  

  这个格式是跟在方法的括号后面的，只是抛出异常，可以抛出多个异常，用逗号隔开。
  3.编译时异常和运行时异常
  也称为：受检异常和非受检异常。所有的RuntimeException类及其子类被称之为运行时异常。其他的异常都是编译时异常。
• 编译时异常：必须显示处理，否则程序就会发生错误，无法通过编译
• 运行时异常：无需显处理,也可以和编译时异常一样处理

4.自定义异常
格式：

	public class 异常类名 extends Exception{
		无参构造;
		带参构造;
	}

范例：

	public class ScoreException extends Exception {
		public ScoreException(){}
		public ScoreException(String message){
			super(message);
			}
		}

在方法中抛出异常

	 public void withdraw(double amount) throws
                              ScoreException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new ScoreException(needs);//注意这里新建一个异常对象，用的是throw
      }
   }

throws和throw的区别

throws	throw
用在方法声明后面，跟的是异常类名	用在方法体内，跟的是异常对象名
表示抛出异常，由该方法的调用者来处理	表示抛出异常，由方法体内的语句处理
表示出现异常的一种可能性,并不一定会发生这些异常	执行throw 一定抛出了某种异常