0%

6.27~6.27继承 -> 多态 -> 抽象 -> 接口 -> 异常

发表于 更新于 分类于 阅读次数：
本文字数： 3.2k 阅读时长 ≈ 3 分钟

2017年7月1日 上午9:30

1.继承

修饰符

修饰符：
本类 同包 子类 其他（不同包） 唯一的标准
private 🐶 是否在 同一个类
frendly 🐶 是否在 同包 默认的
protect 🐶 是否 继承
public 🐶 都

final

1. 方法          重写
2. 类              继承
3. 变量属性  修改

（当变量为对象时，final对象不可以=new Object()，但是仍然可以改变这个对象的属性）

super()

1. super只能在写方法中
1
2
3
4
5
6
7
8
9
package package1;
import package2.A;

public class B extends A {
	//super.a =2;//Syntax error on token "{", { expected after this token
	public B(){
		super.a =2;
	}
}
2. super不在过构造方法时，可以不放在第一行
3. super不能访问父类private成员
4. super()
5. super(a,b) 调用带参构造
6. super.属性
7. super.方法

继承的重写 方法的重载 对比

重写的条件
1. 类型相同/父类返回类型的子类
2. 修饰符只能扩大，不能缩小
3. 方法名，参数列表相同
4. 构造方法不能重写

重写之后的方法调用：

1
2
3
4
5
pet dog = new dog();
dog.print();//默认调用子类的print方法（print方法，子类父类中都有）

pet dog = new dog();
dog.method();//不能调用子类特有方法（method 只有子类中有）

重载的条件
1. 同一个类中
2. 参数列表不同
3. 方法名相同
4. 和返回值，访问修饰符无关

instanceof

1. pet instanceof Dog 
2. instanceof 使用：对象.instanceof(父类/接口)

2.多态

多态概念+要求（多态的前提是继承）

多态概念：同一个引用类型，使用不同的实例而执行不同操作
父类存在的地方一般都能使用子类代替

1. 要素：
    1. 子类重写父类分方法
    2. 使用父类的类型
2. 使用的地方：
    1. 方法参数
    2. 方法返回值

对java继承的测试（通过this）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//父类
	package package3;

	public class Car {
		private int site = 4; //座位数 
		
		Car(){
			System.out.println ("载客量是"+site+"人");
		}
		public void setSite(int site){ 
			this.site = site;
		}
		void print(){
			System.out.print("载客量是"+this.site+"人"); 
		}
	}

	//子类
	package package3;

	public class Bus extends Car {
		Bus(int site){
			//这三个的输出结果是一样的
			//this.setSite(site); 
			//super.setSite(site);
			setSite(site);
		}
	//	public void setSite(int site){ 
	//		super.site = site;
	//		//this.site = site;
	//	}
	}

	//测试类
	package package3;

	public class Test {

		public static void main(String[] args) {
			// TODO Auto-generated method stub
			Bus bus = new Bus(20);
			bus.print();

		}

	}

总结：
1. 在继承中，如果子类没有重写父类的方法，那么子类是调用的是父类的方法
2. 这里的调用，是在父类中执行，而不是在子类中执行（原来理解的是在子类中执行）
3. 因为：继承下来的setSite()方法中写的是this，java有一下几种
1. 继承下来将this改为super，那么就无法操作父类中的私有方法，所以不可能
2. 子类中还是保持this，那么，this指代的是子类，所以不可能父类私有属性，所以不可能
3. 这个this还是指向的父类，那么，说明本身父类也是存在的，像C++一样，在产生子类对象的时候，父类对象其实也产生了，那么这个setSite()其实父类对象自己执行的
4. 这三个的输出结果是一样的
this.setSite(site);
super.setSite(site);
setSite(site);
5. 继承不是拥有这项技能，而是能让父类帮你干，你自己其实不会。

3.抽象

抽象类要求

1. 抽象类不能实例化  --- 因为没有意义
2. `Pet pet = new Dog() //pet是abstract`
3. 是对的  这只是一个指针指向 没有分配空间进行实例化
4. 抽象类中可以有0个或者多个抽象方法  
5. 子类中，抽象方法在子类中必须实现

接口

接口的要求

1. 接口不能实例化
2. 实现类必须实现接口的所有方法
3. 变量都是静态变量
4. 现类可以实现多个接口
5. 方法：public abstract void service();   不能用static
6. 变量：public static final  double PI = 3.14;

总结

  1. 现在对比下来继承绝对是老大，知识点多。
  2. 继承是 多态 + 重写 的前提
  3. 继承+抽象 +接口在生成对象比较
    继承：
    继承就不用说了，多态的上转型的概念理解的就像！

抽象：

1
MotoVehicle moto[] =new MotoVehicle[4];
1. **这个MotoVehicle是abstract类**，但是能用new，这个例子就充分的说明了，new ！= 分配空间。
2. 在这里，他仅仅说明了moto[]的长度
3. **对象初始化挪到了后面，为了集中说明一个知识点！**

接口：

1
2
3
4
5
6
7
8
9
10
11
public class Test1 implements Interface1 {
	@Override
	public void fun() {
		// TODO Auto-generated method stub
		System.out.println("fun");
	}
	public static void main(String args[]){
		Interface1  t = new Test1();
		t.fun();
	}
}

对比三个发现：父类 抽象类 接口 这三个都可以
1. 直接声明对象
2. 调用对象的方法
3. 但是，不可以初始化对象本身（父类初始化自己）

错误

对象数组的初始化方法：
第一种：

1
2
3
4
5
6
7
8
MotoVehicle moto[] = new MotoVehicle[]{
		new Car(1,"宝马1","红色",1000,20),
		new Car(2,"宝马2","红色",1000,20),
		new Bus(3,"金龙1","绿色",1000,"x"),
		new Bus(3,"金龙2","绿色",1000,"xx"),
		new Bus(5,"金龙3","绿色",1000,"xxx"),
		new Ka(6,"Ka1","兰色",1000,100)
};
第二种：
1
2
3
for(int i = 0 ;i < n;i++){
			moto[i]= new Car(**);//只能生成一种Car类型的
		}

对象的强制转换错误：

1
2
Dog dog = （Dog）pet;//强制转换
(Dog)pet.dark();//这的是错的，之后转换了之后才可以进行特有dog方法的调用