Java高级特性1

目录

• 1. 继承
  • 1.1 语法
  • 1.2 作用
  • 1.3 类的继承
• 2. 方法的重写(override)
  • 2.1 定义
• 3. 四种访问权限修饰符
• 4. 关键字super
• 5. 子类对象实例化过程
  • 5.1 简单类对象的实例化过程
  • 5.2 子类对象的实例化过程!
• 6. 多态
  • 6.1 在java中有两种体现
  • 6.2向上转型(upcasting)
  • 6.3虚拟方法调用(Virtual Method Invocation)
• 7. Object类、包装类
  • 7.1 instanceof 操作符
  • 7.2 Object类的主要方法
  • 7.3 String对象的创建
  • 7.4 toString() 方法
  • 7.5 包装类

1. 继承

1.1 语法

class Subclass extends Superclass{ }

1.2 作用

1. 继承的出现提高了代码的复用性。
2. 继承的出现让类与类之间产生了关系，提供了多态的前提。
3. 不要仅为了获取其他类中某个功能而去继承。

1.3 类的继承

1. 子类继承了父类，就继承了父类的方法和属性。
2. 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
3. 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”
4. 子类不能直接访问父类中私有的(private)的成员变量和方法
5. Java只支持单继承，不允许多重继承

2. 方法的重写(override)

2.1 定义

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法
要求：

1. 重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。
2. 重写方法不能使用比被重写方法更严格的访问权限。
3. 重写和被重写的方法须同时为static的，或同时为非static的
4. 子类方法抛出的异常不能大于父类被重写方法的异常
5. 子类不能访问父类私有的东西

3. 四种访问权限修饰符

如果子类和父类在同一个包下面，那么对于父类的成员修饰符只要不是私有的private,那么子类都可以使用
如果子类和父类不在同一个包下面，那么子类只能使用父类中的proteced和public修饰的成员

4. 关键字super

在Java类中使用super来调用父类中的指定操作：

1. super可用于访问父类中定义的属性
2. super可用于调用父类中定义的成员方法
3. super可用于在子类构造方法中调用父类的构造器

注意：

1. 尤其当子父类出现同名成员时，可以用super进行区分
2. super的追溯不仅限于直接父类
3. super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

调用父类的构造器

1. 子类中所有的构造器默认都会访问父类中空参数的构造器
2. 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行
3. 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错
   ** this和super的区别**

5. 子类对象实例化过程

5.1 简单类对象的实例化过程

5.2 子类对象的实例化过程!

6. 多态

6.1 在java中有两种体现

1. 方法的重载(overload)和重写(overwrite)。
2. 对象的多态性 ——可以直接应用在抽象类和接口上。
   Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。
   若编译时类型和运行时类型不一致，就出现多态（Polymorphism）
   对象的多态 —在Java中,子类的对象可以替代父类的对象使用

	Person e = new Student(); // Person类型的变量e，指向Student类型的对象

6.2向上转型(upcasting)

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法,原因是属性是在编译时确定的；编译时时父类类型，没有子类成员变量

Student m = new Student();
	m.school = “pku”; 	//合法,Student类有school成员变量
	Person e = new Student(); 
	e.school = “pku”;	//非法,Person类没有school成员变量
      属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

6.3虚拟方法调用(Virtual Method Invocation)

编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定

Person e = new Student();
    	e.getInfo();	//调用Student类的getInfo()方法

小结:
前提：

1. 需要存在继承或者实现关系
2. 要有覆盖操作

成员方法：

1. 编译时：要查看引用变量所属的类中是否有所调用的方法。
2. 运行时：调用实际对象所属的类中的重写方法。
   成员变量：
3. 不具备多态性，只看引用变量所属的类。
   多态性应用举例
   方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

public class Test{ 
	public void method(Person e) {
	           //……
	           e.getInfo();
	}
	public static  void main(Stirng args[]){
	           Test t = new Test();
	            Student m = new Student();
	            t.method(m); //子类的对象m传送给父类类型的参数e
	}
}

7. Object类、包装类

7.1 instanceof 操作符

		//instanceof 判断一个对象（对象的实际指向）是否是类A的子类
		Circle c2 = new Cylinder(); 
		System.out.println(c instanceof Circle);
		System.out.println(c1 instanceof Cylinder);

7.2 Object类的主要方法

		//object类，是所有类的父类，在你知道形参要使用什么类的时候，可以使用object类
		Object o = new Circle();
		//object类具有的方法
		System.out.println(c1.equals(c2));//对象1.equals 对象2；判断对象的引用是否是同一个
		System.out.println(c1.equals(c));
		System.out.println(c1.equals(o));
		c1 = c2;
		//object是所有类的父类，所以所有类都可以执行object的方法
		System.out.println(c1.equals(c2));//直接将c2的引用赋给c1，是同一个引用为TRUE；
		//
		System.out.println(o.hashCode());//一串hash码//873415566
		//tostring打印对象时使用
		System.out.println(o.toString());//当前引用的对象的内存地址//com.day03.Circle@340f438e

7.3 String对象的创建

7.4 toString() 方法

//toString()方法：对象的内存地址,可以通过重写tostring方法来重新定义方法
//		Student s3 = new Student();//com.day04.Student@511baa65
//		System.out.println(s3);
		
		//重写toString（）方法
		Student s4 = new Student();		
		System.out.println(s4.toString());//2019-11-27
		System.out.println(s4);//打印对象相当于执行.toString（）方法，这在其他对象也是如此

7.5 包装类

1. 基本数据类型包装成包装类的实例 ---装箱
2. 获得包装类对象中包装的基本类型变量 ---拆箱
3. JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

/**
		 * 包装类:
		 * 1.针对八种基本类型定义相应的引用类型-包装类(封装类)
		 * 2.有了类的特点，就可以调用类中的方法
		 * 
		 * 主要做的是基本数据类型与字符串直接的转化
		 * xxx b = Xxx.xxxparsexxx()字符串转基本类型
		 * String s = String.valueOf(xxx);基本类型转字符串
		 */
		Integer i = new Integer(123);//装箱
		int i1 = i.intValue();//拆箱
		System.out.println(i1);
		
		//现在有自动装箱和拆箱
		Integer i2 = 124;//自动装箱
		int i3 = i2;//自动拆箱
		
		//匿名
		Boolean b = true;//装箱
		boolean b1 = new Boolean("false");//拆箱
		
		//字符串转换成其他基本类型
		float f = Float.parseFloat("11.3");
		System.out.println(f);
		boolean b2 = Boolean.parseBoolean("false");
		
		//基本数据类型转字符串
		String s = String.valueOf(f);
		System.out.println(s);
		String s1 = String.valueOf(b2);
		String s2 = String.valueOf(b);
		System.out.println(b2+"t"+b);