黑马程序员-------面向对象基础知识2

第一讲 继承

1. 为什么会有继承？

在平时写代码的过程中，发现很多类都是具有共性的，将这些共性抽取出来变成一个父类，通过继承的方式来改进或者实现这些共性

2. 继承概述
把多个类中相同的内容给提取出来定义到一个类中。

如何实现继承呢?
Java提供了关键字：extends

格式：
class 子类名 extends 父类名 {}

好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类之间产生了关系，是多态的前提

类与类产生了关系，其实也是继承的一个弊端：
类的耦合性增强了。

开发的原则：低耦合，高内聚。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

3.Java中继承的特点：
A:Java只支持单继承，不支持多继承。
有些语言是支持多继承，格式：extends 类1,类2,...
B:Java支持多层继承(继承体系)

4.继承的注意事项：
A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
B:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
C:不要为了部分功能而去继承

那么，我们什么时候考虑使用继承呢?
继承其实体现的是一种关系："is a"。比如说：爸爸是个人，狗是个动物

继承示例：

//使用继承前
/*
class Student {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}

class Teacher {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}
*/

//使用继承后
class Person {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}

class Student extends Person {}

class Teacher extends Person {}

class ExtendsDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.eat();//调用Person的方法
		s.sleep();//调用Person的方法
		System.out.println("-------------");
		
		Teacher t = new Teacher();
		t.eat();//调用Person的方法
		t.sleep();//调用Person的方法
	}
}

注意：

Java中继承的特点：
A:Java只支持单继承，不支持多继承。
有些语言是支持多继承，格式：extends 类1,类2,...
B:Java支持多层继承(继承体系)

class Father {}
class Mother {}
class Son exnteds Father {} //正确的
class Son extends Father,Mother {} // 错误的

5.super关键字

用于在子类中,可以直接访问父类的数据

this和super的区别
分别是什么呢?
this代表本类对应的引用。
super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员

怎么用呢?
A:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
B:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
C:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法

6.方法的继承(重写)和重载

方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：
本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：
先找子类本身，再找父类。

方法的重写和super的示例:

//定义一个手机类，里面有一个拨打的方法
class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

//继承手机类
class NewPhone extends Phone {
	public void call(String name) {
		//重写call方法并且使用supper调用父类方法
		super.call(name);
		System.out.println("可以听天气预报了");
	}
}

class ExtendsDemo9 {
	public static void main(String[] args) {
		NewPhone np = new NewPhone();
		np.call("林青霞");
	}
}

方法重写的注意事项
A:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B:子类重写父类方法时，访问权限不能更低
最好就一致
C:父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解

子类重写父类方法的时候，最好声明一模一样。

第二讲 多态

1. 多态概述：

同一个对象(事物)，在不同时刻体现出来的不同状态。

比如说猫是猫。猫也是动物

2.多态的前提：
A:要有继承关系。
B:要有方法重写。
其实没有也是可以的，但是如果没有这个就没有意义。
动物 d = new 猫();
d.show();
动物 d = new 狗();
d.show();
C:要有父类引用指向子类对象。
父 f =  new 子();

3.多态中的成员访问特点：
A:成员变量
编译看左边，运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边。
D:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)

由于成员方法存在方法重写，所以它运行看右边。

对于运行和编译的特点，有个示例：

class Fu {
	public int num = 100;

	public void show() {
		System.out.println("show Fu");
	}
	
	public static void function() {
		System.out.println("function Fu");
	}
}

class Zi extends Fu {
	public int num = 1000;
	public int num2 = 200;

	public void show() {
		System.out.println("show Zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}
	
	public static void function() {
		System.out.println("function Zi");
	}
}

class DuoTaiDemo {
	public static void main(String[] args) {
		//要有父类引用指向子类对象。
		//父 f =  new 子();
		Fu f = new Zi();
		System.out.println(f.num);
		//找不到符号
		//System.out.println(f.num2);
		
		f.show();
		//找不到符号
		//f.method();
		f.function();
	}
}

可以看出，最后的结果是符合多态成员访问特点的

第三讲 内部类

1. 内部类概述:
把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。

内部的访问特点：
A:内部类可以直接访问外部类的成员，包括私有。
B:外部类要访问内部类的成员，必须创建对象。

简单示例：

class Outer {
	private int num = 10;
	
	class Inner {
		public void show() {
			System.out.println(num);
		}
	}
	
	public void method() {
		//找不到符号
		//show();
	
		Inner i = new Inner();
		i.show();
	}
}

2.内部类位置
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。
示例：

class Outer {


//成员位置

class Inner1 {

}
public void method() {
//局部位置
class Inner2 {

}
}
}

3.成员内部类:
如何直接访问内部类的成员。
外部类名.内部类名 对象名 = 外部类对象.内部类对象;

示例：

Outer.Inner oi = new Outer().new Inner();

成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意：静态内部类访问的外部类数据必须用静态修饰。

4.局部内部类
A:可以直接访问外部类的成员
B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

class Outer {
private int num  = 10;

public void method() {
class Inner {
public void show() {
}
}
}
}

5.匿名内部类

就是内部类的简化写法。

前提：存在一个类或者接口
这里的类可以是具体类也可以是抽象类。

格式：
new 类名或者接口名(){
重写方法;
}
匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象。

 好处：简化书写
 弊端：1、不能直接调用自己的特有方法、
       2、不能做强转动作。
       3、如果继承的父类或接口中有很多方法时，使用匿名内部类阅读性会非常差，且调用会很麻烦。所以匿名内部类中定义的方法有一般不超过3个。

interface Inter {
	public abstract void show();
	public abstract void show2();
}

class Outer {
	public void method() {
		//一个方法的时候
		/*
		new Inter() {
			public void show() {
				System.out.println("show");
			}
		}.show();
		*/
		
		//二个方法的时候
		/*
		new Inter() {
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		}.show();
		
		new Inter() {
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		}.show2();
		*/
		
		//如果我是很多个方法，就很麻烦了
		//那么，我们有没有改进的方案呢?
		Inter i = new Inter() { //多态
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		};
		
		i.show();
		i.show2();
	}
}

class InnerClassDemo6 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

第四讲 包

1.包的概述

在java中，管叫包，相当于文件夹。包里通常存放的是类文件，
因为我们在编写程序的时候，难免会有类名相同的情况，就如我们人名一样。
为了对类进行分类管理，java就有了包的出现，在不同包中可以有相同的类名，
调用的时候连同包名一起就行。 包也是一种封装形式。在包中可以有很多类文件，但是只提供一个类文件，供外界使用。

2. 包的定义

package 包名;
多级包用.分开即可

注意事项:
A:package语句必须是程序的第一条可执行的代码
B:package语句在一个java文件中只能有一个
C:如果没有package，默认表示无包名
3.包之间的访问

a、要访问其他包中的类，需要定义类的全称：包名.类名。
b、包如果不在当前路径，需要使用classpath设定环境变量，为JVM指明路径。
c、被访问的包中的类权限必须是public的。
d、类中的成员权限：public或者protected。protected是为其他包中的子类提供的一种权限。
类公有后，被访问的成员也要公有才可以被访问。不同包中的子类可以直接访问父类中被protected权限修饰的成员。同一个包中，protected只作用为覆盖。

四种权限

权限修饰符：
本类 同一个包下(子类和无关类)                   不同包下(子类)    不同包下(无关类)
private Y N N N
默认 Y Y N N
protected Y Y Y N
public Y Y Y Y

4.包的导入

格式：import 包名;
这种方式导入是到类的名称。
注意：我们用谁就导谁。

下面是一个关于导入包的示例

一个demo小程序

package com.abcd;

public class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}

导入这个包并运用

package cn.itcast;

import com.abcd.Demo;

class Test {
	public static void main(String[] args) {
		Demo d = new Demo();
		System.out.println(d.sum(10,20));
	}
}