1. 首先我来写两个代码:
// 定义学生类
class Student {
String name;
int age;
public Student(){}
//getXxx()/setXxx()
public void eat() {
System.out.println(" 吃饭 ");
}
}
// 定义老师类
class Teacher {
String name;
int age;
public Teacher(){}
//getXxx()/setXxx()
public void eat() {
System.out.println(" 吃饭 ");
}
}
我们观察上面两个代码:
发现name , age 成员变量,以及 getXxx()/setXxx(), 还有 eat() 等都是相同的。
如果我们后来继续定义类,举例:工人类,军人类。他们是不是也具备这些内容。
那么,我们每一次定义这样的类的时候,都要把这些重复的内容都重新定义一遍。
麻烦不? 麻烦。所以,我们要考虑改进 ?
如何改进呢?
我这想的:我能不能把这些相同的内容给定义到一个独立的类中。
然后,让这多个类和这个独立的类产生一个关系,有了这个关系后,
这多个类就可以具备这个独立的类的功能。
为了实现这个效果,java 就提供了一个技术:继承。
父亲:
4 个儿子
继承怎么表示呢? 继承的格式是什么样子的呢 ?
class Fu {}
class Zi extends Fu {
}
我们就回头修改我们的代码:
class Person {
String name;
int age;
public Person(){}
//getXxx()/setXxx()
public void eat() {
System.out.println(" 吃饭 ");
}
}
class Student extends Person {
public Student(){}
}
class Teacher extends Person {
public Teacher(){}
}
2.继承概述
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
通过extends 关键字可以实现类与类的继承
class 子类名 extends 父类名 {}
单独的这个类称为父类,基类或者超类;这多个类可以称为子类或者派生类。
有了继承以后,我们定义一个类的时候,可以在一个已经存在的类的基础上,还可以定义自己的新成员。
3.继承概述:
把多个类中相同的内容给提取出来定义到一个类中。
如何实现继承呢?
Java 提供了关键字: extends
格式:
class 子类名 extends 父类名 {}
好处:
A: 提高了代码的复用性
B: 提高了代码的维护性
C: 让类与类之间产生了关系,是多态的前提
类与类产生了关系,其实也是继承的一个弊端:
类的耦合性增强了。
开发的原则:低耦合,高内聚。
耦合:类与类的关系
内聚:就是自己完成某件事情的能力
*/
// 使用继承前
/*
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();
s.sleep();
System.out.println("-------------");
Teacher t = new Teacher();
t.eat();
t.sleep();
}
}
4.Java中继承的特点
Java 只支持单继承,不支持多继承。
一个类只能有一个父类,不可以有多个父类。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...// error
Java 支持多层继承 ( 继承体系 )
class A{}
class B extends A{}
class C extends B{}
5.继承的注意事项:
A: 子类不能继承父类的私有成员
B: 子类不能继承父类的构造方法,但是可以通过 super 去访问
C: 不要为了部分功能而去继承
6.什么时候使用继承呢?
A: 继承体现的是: is a 的关系。
B: 采用假设法
7.Java继承中的成员关系
A: 成员变量
a: 子类的成员变量名称和父类中的成员变量名称不一样,这个太简单
b: 子类的成员变量名称和父类中的成员变量名称一样,这个怎么访问呢 ?
子类的方法访问变量的查找顺序:
在子类方法的局部范围找,有就使用。
在子类的成员范围找,有就使用。
在父类的成员范围找,有就使用。
找不到,就报错。
B: 构造方法
a: 子类的构造方法默认会去访问父类的无参构造方法
是为了子类访问父类数据的初始化
b: 父类中如果没有无参构造方法,怎么办 ?
子类通过super 去明确调用带参构造
子类通过this 调用本身的其他构造,但是一定会有一个去访问了父类的构造
让父类提供无参构造
C: 成员方法
a: 子类的成员方法和父类中的成员方法名称不一样,这个太简单
b: 子类的成员方法和父类中的成员方法名称一样,这个怎么访问呢 ?
通过子类对象访问一个方法的查找顺序:
在子类中找,有就使用
在父类中找,有就使用
找不到,就报错
8.问题是:
我不仅仅要输出局部范围的num ,还要输出本类成员范围的 num 。怎么办呢 ?
我还想要输出父类成员范围的num 。怎么办呢 ?
如果有一个东西和this 相似,但是可以直接访问父类的数据就好了。
恭喜你,这个关键字是存在的:super 。
9.this和super的区别?
分别是什么呢?
this 代表本类对应的引用。
super 代表父类存储空间的标识 ( 可以理解为父类引用 , 可以操作父类的成员 )
怎么用呢?
A: 调用成员变量
this. 成员变量 调用本类的成员变量
super. 成员变量 调用父类的成员变量
B: 调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
C: 调用成员方法
this. 成员方法 调用本类的成员方法
super. 成员方法 调用父类的成员方法
*/
class Father {
public int num = 10;
}
class Son extends Father {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
class ExtendsDemo5 {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}
9).继承中构造方法的关系
A: 子类中所有的构造方法默认都会访问父类中空参数的构造方法
B: 为什么呢 ?
因为子类会继承父类中的数据,可能还会使用父类的数据。
所以,子类初始化之前,一定要先完成父类数据的初始化。
注意:子类每一个构造方法的第一条语句默认都是:super();
10).如果父类没有无参构造方法,那么子类的构造方法会出现什么现象呢?
报错。
如何解决呢?
A: 在父类中加一个无参构造方法
B: 通过使用 super 关键字去显示的调用父类的带参构造方法
C: 子类通过 this 去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法,否则父类数据就没有初始化。
注意事项:
this(...) 或者 super(...) 必须出现在第一条语句上。
如果不是放在第一条语句上,就可能对父类的数据进行了多次初始化,所以必须放在第一条语句上。
11) .继承中面试题
1. 看程序写结果:
A: 成员变量 就近原则
B:this 和 super 的问题
this 访问本类的成员
super 访问父类的成员
C: 子类构造方法执行前默认先执行父类的无参构造方法
D: 一个类的初始化过程
成员变量进行初始化
默认初始化
显示初始化
构造方法初始化
结果:
fu
zi
30
20
10
*/
class Fu{
public int num = 10;
public Fu(){
System.out.println("fu");
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi");
}
public void show(){
int num = 30;
System.out.println(num); //30
System.out.println(this.num); //20
System.out.println(super.num); //10
}
}
class ExtendsTest {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
2./*
看程序写结果:
A: 一个类的静态代码块 , 构造代码块 , 构造方法的执行流程
静态代码块 > 构造代码块 > 构造方法
B: 静态的内容是随着类的加载而加载
静态代码块的内容会优先执行
C: 子类初始化之前先会进行父类的初始化
结果是:
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
*/
class Fu {
static {
System.out.println(" 静态代码块 Fu");
}
{
System.out.println(" 构造代码块 Fu");
}
public Fu() {
System.out.println(" 构造方法 Fu");
}
}
class Zi extends Fu {
static {
System.out.println(" 静态代码块 Zi");
}
{
System.out.println(" 构造代码块 Zi");
}
public Zi() {
System.out.println(" 构造方法 Zi");
}
}
class ExtendsTest2 {
public static void main(String[] args) {
Zi z = new Zi();
}
}
3. 看程序写结果:
A: 成员变量的问题
int x = 10; // 成员变量是基本类型
Student s = new Student(); // 成员变量是引用类型
B: 一个类的初始化过程
成员变量的初始化
默认初始化
显示初始化
构造方法初始化
C: 子父类的初始化 ( 分层初始化 )
先进行父类初始化,然后进行子类初始化。
结果:
YXYZ
问题:
虽然子类中构造方法默认有一个super()
初始化的时候,不是按照那个顺序进行的。
而是按照分层初始化进行的。
它仅仅表示要先初始化父类数据,再初始化子类数据。
*/
class X {
Y b = new Y();
X() {
System.out.print("X");
}
}
class Y {
Y() {
System.out.print("Y");
}
}
public class Z extends X {
Y y = new Y();
Z() {
//super
System.out.print("Z");
}
public static void main(String[] args) {
new Z();
}
}
12.继承中成员方法的关系:
A: 子类中的方法和父类中的方法声明不一样,这个太简单。
B: 子类中的方法和父类中的方法声明一样,这个该怎么玩呢 ?
通过子类对象调用方法:
a: 先找子类中,看有没有这个方法,有就使用
b: 再看父类中,有没有这个方法,有就使用
c: 如果没有就报错。
*/
class Father {
public void show() {
System.out.println("show Father");
}
}
class Son extends Father {
public void method() {
System.out.println("method Son");
}
public void show() {
System.out.println("show Son");
}
}
class ExtendsDemo8 {
public static void main(String[] args) {
// 创建对象
Son s = new Son();
s.show();
s.method();
//s.fucntion(); // 找不到符号
}
13. 方法重写:子类中出现了和父类中方法声明一模一样的方法。
方法重载:本类中出现的方法名一样,参数列表不同的方法。与返回值无关。
子类对象调用方法的时候:
先找子类本身,再找父类。
方法重写的应用:
当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法。
这样,即沿袭了父类的功能,又定义了子类特有的内容。
案例:
A: 定义一个手机类。
B: 通过研究,我发明了一个新手机,这个手机的作用是在打完电话后,可以听天气预报。
按照我们基本的设计,我们把代码给写出来了。
但是呢? 我们又发现新手机应该是手机,所以,它应该继承自手机。
其实这个时候的设计,并不是最好的。
因为手机打电话功能,是手机本身就具备的最基本的功能。
所以,我的新手机是不用在提供这个功能的。
但是,这个时候,打电话功能就没有了。这个不好。
最终,还是加上这个功能。由于它继承了手机类,所以,我们就直接使用父类的功能即可。
那么,如何使用父类的功能呢? 通过 super 关键字调用
*/
class Phone {
public void call(String name) {
System.out.println(" 给 "+name+" 打电话 ");
}
}
class NewPhone extends Phone {
public void call(String name) {
//System.out.println(" 给 "+name+" 打电话 ");
super.call(name);
System.out.println(" 可以听天气预报了 ");
}
}
class ExtendsDemo9 {
public static void main(String[] args) {
NewPhone np = new NewPhone();
np.call(" 林青霞 ");
}
}
14. 方法重写的注意事项
A: 父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B: 子类重写父类方法时,访问权限不能更低
最好就一致
C: 父类静态方法,子类也必须通过静态方法进行重写
其实这个算不上方法重写,但是现象确实如此,至于为什么算不上方法重写, 多态中我会讲解
子类重写父类方法的时候,最好声明一模一样。
15. 两个面试题
1 ):方法重写和方法重载的区别 ? 方法重载能改变返回值类型吗 ?
方法重写:
在子类中,出现和父类中一模一样的方法声明的现象。
方法重载:
同一个类中,出现的方法名相同,参数列表不同的现象。
方法重载能改变返回值类型,因为它和返回值类型无关。
Override :方法重写
Overload :方法重载
2 ): this 关键字和 super 关键字分别代表什么 ? 以及他们各自的使用场景和作用。
this: 代表当前类的对象引用
super: 代表父类存储空间的标识。 ( 可以理解为父类的引用,通过这个东西可以访问父类的成员 )
场景:
成员变量:
this. 成员变量
super. 成员变量
构造方法:
this(...)
super(...)
成员方法:
this. 成员方法
super. 成员方法
16. 学生案例和老师案例讲解
学生:
成员变量;姓名,年龄
构造方法:无参,带参
成员方法:getXxx()/setXxx()
老师:
成员变量;姓名,年龄
构造方法:无参,带参
成员方法:getXxx()/setXxx()
看上面两个类的成员,发现了很多相同的东西,所以我们就考虑抽取一个共性的类:
人:
成员变量;姓名,年龄
构造方法:无参,带参
成员方法:getXxx()/setXxx()
学生 继承 人
老师 继承 人
*/
// 定义人类
class Person {
// 姓名
private String name;
// 年龄
private int age;
public Person() {
}
public Person(String name,int age) { //" 林青霞 ",27
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
// 定义学生类
class Student extends Person {
public Student() {}
public Student(String name,int age) { //" 林青霞 ",27
//this.name = name;
//this.age = age;
super(name,age);
}
}
// 定义老师类
class Teacher extends Person {
}
class ExtendsTest4 {
public static void main(String[] args) {
// 创建学生对象并测试
// 方式 1
Student s1 = new Student();
s1.setName(" 林青霞 ");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
// 方式 2
Student s2 = new Student(" 林青霞 ",27);
System.out.println(s2.getName()+"---"+s2.getAge());
// 补齐老师类中的代码并进行测试。
}
}
17. 猫狗案例讲解
猫:
成员变量:姓名,年龄,颜色
构造方法:无参,带参
成员方法:
getXxx()/setXxx()
eat()
palyGame()
狗:
成员变量:姓名,年龄,颜色
构造方法:无参,带参
成员方法:
getXxx()/setXxx()
eat()
lookDoor()
共性:
成员变量:姓名,年龄,颜色
构造方法:无参,带参
成员方法:
getXxx()/setXxx()
eat()
把共性定义到一个类中,这个类的名字叫:动物。
动物类:
成员变量:姓名,年龄,颜色
构造方法:无参,带参
成员方法:
getXxx()/setXxx()
eat()
猫:
构造方法:无参,带参
成员方法:palyGame()
狗:
构造方法:无参,带参
成员方法:lookDoor()
*/
// 定义动物类
class Animal {
// 姓名
private String name;
// 年龄
private int age;
// 颜色
private String color;
public Animal() {}
public Animal(String name,int age,String color) {
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat() {
System.out.println(" 不要睡了 , 该吃饭了 ");
}
}
// 定义猫类
class Cat extends Animal {
public Cat() {}
public Cat(String name,int age,String color) {
super(name,age,color);
}
public void playGame() {
System.out.println(" 猫玩英雄联盟 ");
}
}
// 定义狗类
class Dog extends Animal {
public Dog() {}
public Dog(String name,int age,String color) {
super(name,age,color);
}
public void lookDoor() {
System.out.println(" 狗看家 ");
}
}
// 测试类
class ExtendsTest5 {
public static void main(String[] args) {
// 测试猫
// 方式 1
Cat c1 = new Cat();
c1.setName("Tom");
c1.setAge(3);
c1.setColor(" 白色 ");
System.out.println(" 猫的名字是: "+c1.getName()+"; 年龄是: "+c1.getAge()+"; 颜色是: "+c1.getColor());
c1.eat();
c1.playGame();
System.out.println("---------------");
// 方式 2
Cat c2 = new Cat(" 杰瑞 ",5," 土豪金 ");
System.out.println(" 猫的名字是: "+c2.getName()+"; 年龄是: "+c2.getAge()+"; 颜色是: "+c2.getColor());
c2.eat();
c2.playGame();
二.final关键字
1.继承的代码体现
由于继承中方法有一个现象:方法重写。
所以,父类的功能,就会被子类给覆盖调。
有些时候,我们不想让子类去覆盖掉父类的功能,只能让他使用。
这个时候,针对这种情况,Java就提供了一个关键字:final
final:最终的意思。常见的是它可以修饰类,方法,变量。
2.final可以修饰类,方法,变量
特点:
final可以修饰类,该类不能被继承。
final可以修饰方法,该方法不能被重写。(覆盖,复写)
final可以修饰变量,该变量不能被重新赋值。因为这个变量其实常量。
常量:
A:字面值常量
"hello",10,true
B:自定义常量
final int x = 10;
3. 面试题:
final修饰局部变量的问题
基本类型:基本类型的值不能发生改变。
引用类型:引用类型的地址值不能发生改变,但是,该对象的堆内存的值是可以改变的。
*/
class Student {
int age = 10;
}
class FinalTest {
public static void main(String[] args) {
//局部变量是基本数据类型
int x = 10;
x = 100;
System.out.println(x);
final int y = 10;
//无法为最终变量y分配值
//y = 100;
System.out.println(y);
System.out.println("--------------");
//局部变量是引用数据类型
Student s = new Student();
System.out.println(s.age);
s.age = 100;
System.out.println(s.age);
System.out.println("--------------");
final Student ss = new Student();
System.out.println(ss.age);
ss.age = 100;
System.out.println(ss.age);
//重新分配内存空间
//无法为最终变量ss分配值
ss = new Student();
}
}
4.面试题:
final修饰变量的初始化时机
A:被final修饰的变量只能赋值一次。
B:在构造方法完毕前。(非静态的常量)
class Demo {
//int num = 10;
//final int num2 = 20;
int num;
final int num2;
{
//num2 = 10;
}
public Demo() {
num = 100;
//无法为最终变量num2分配值
num2 = 200;
}
}
class FinalTest2 {
public static void main(String[] args) {
Demo d = new Demo();
System.out.println(d.num);
System.out.println(d.num2);
}
三.多态
1. 多态:同一个对象(事物),在不同时刻体现出来的不同状态。
举例:
猫是猫,猫是动物。
水(液体,固体,气态)。
多态的前提:
A:要有继承关系。
B:要有方法重写。
其实没有也是可以的,但是如果没有这个就没有意义。
动物 d = new 猫();
d.show();
动物 d = new 狗();
d.show();
C:要有父类引用指向子类对象。
父 f = new 子();
用代码体现一下多态。
多态中的成员访问特点:
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();
}
}
3. 多态的好处:
A:提高了代码的维护性(继承保证)
B:提高了代码的扩展性(由多态保证)
4. 多态的弊端:
不能使用子类的特有功能。
我就想使用子类的特有功能?行不行?
行。
怎么用呢?
A:创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,太占内存了)
B:把父类的引用强制转换为子类的引用。(向下转型)
对象间的转型问题:
向上转型:
Fu f = new Zi();
向下转型:
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
*/
class Fu {
public void show() {
System.out.println("show fu");
}
}
class Zi extends Fu {
public void show() {
System.out.println("show zi");
}
public void method() {
System.out.println("method zi");
}
}
class DuoTaiDemo4 {
public static void main(String[] args) {
//测试
Fu f = new Zi();
f.show();
//f.method();
//创建子类对象
//Zi z = new Zi();
//z.show();
//z.method();
//你能够把子的对象赋值给父亲,那么我能不能把父的引用赋值给子的引用呢?
//如果可以,但是如下
Zi z = (Zi)f;
z.show();
z.method();
} }
四.抽象类
1.抽象类的概述:
动物不应该定义为具体的东西,而且动物中的吃,睡等也不应该是具体的。
我们把一个不是具体的功能称为抽象的功能,而一个类中如果有抽象的功能,该类必须是抽象类。
抽象类的特点:
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
C:抽象类不能实例化
因为它不是具体的。
抽象类有构造方法,但是不能实例化?构造方法的作用是什么呢?
用于子类访问父类数据的初始化
D:抽象的子类
a:如果不想重写抽象方法,该子类是一个抽象类。
b:重写所有的抽象方法,这个时候子类是一个具体的类。
抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
Animal a = new Cat();
*/
//abstract class Animal //抽象类的声明格式
abstract class Animal {
//抽象方法
//public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
public abstract void eat();
public Animal(){}
}
//子类是抽象类
abstract class Dog extends Animal {}
//子类是具体类,重写抽象方法
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
}
class AbstractDemo {
public static void main(String[] args) {
//创建对象
//Animal是抽象的; 无法实例化
//Animal a = new Animal();
//通过多态的方式
Animal a = new Cat();
a.eat();
}
}
2. 抽象类的成员特点:
成员变量:既可以是变量,也可以是常量。
构造方法:有。
用于子类访问父类数据的初始化。
成员方法:既可以是抽象的,也可以是非抽象的。
抽象类的成员方法特性:
A:抽象方法 强制要求子类做的事情。
B:非抽象方法 子类继承的事情,提高代码复用性。
3. 抽象类的几个小问题
A:抽象类有构造方法,不能实例化,那么构造方法有什么用?
用于子类访问父类数据的初始化
B:一个类如果没有抽象方法,却定义为了抽象类,有什么用?
为了不让创建对象
C:abstract不能和哪些关键字共存
a:final 冲突
b:private 冲突
c:static 无意义
4. 接口的特点:
A:接口用关键字interface表示
interface 接口名 {}
B:类实现接口用implements表示
class 类名 implements 接口名 {}
C:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式来实例化。
D:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
由此可见:
A:具体类多态(几乎没有)
B:抽象类多态(常用)
C:接口多态(最常用)
*/
//定义动物培训接口
interface AnimalTrain {
public abstract void jump();
}
//抽象类实现接口
abstract class Dog implements AnimalTrain {
}
//具体类实现接口
class Cat implements AnimalTrain {
public void jump() {
System.out.println("猫可以跳高了");
}
}
class InterfaceDemo {
public static void main(String[] args) {
//AnimalTrain是抽象的; 无法实例化
//AnimalTrain at = new AnimalTrain();
//at.jump();
AnimalTrain at = new Cat();
at.jump();
}
}
5.接口成员特点
成员变量;只能是常量,并且是静态的。
默认修饰符:public static final
建议:自己手动给出。
构造方法:接口没有构造方法。
成员方法:只能是抽象方法。
默认修饰符:public abstract
建议:自己手动给出。
所有的类都默认继承自一个类:Object。
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
*/
interface Inter {
public int num = 10;
public final int num2 = 20;
public static final int num3 = 30;
//错误: 需要<标识符>
//public Inter() {}
//接口方法不能带有主体
//public void show() {}
//abstract void show(); //默认public
public void show(); //默认abstract
}
//接口名+Impl这种格式是接口的实现类格式
/*
class InterImpl implements Inter {
public InterImpl() {
super();
}
}
*/
class InterImpl extends Object implements Inter {
public InterImpl() {
super();
}
public void show() {}
}
//测试类
class InterfaceDemo2 {
public static void main(String[] args) {
//创建对象
Inter i = new InterImpl();
System.out.println(i.num);
System.out.println(i.num2);
//i.num = 100;
//i.num2 = 200;
//System.out.println(i.num); //无法为最终变量num分配值
//System.out.println(i.num2);//无法为最终变量num2分配值
System.out.println(Inter.num);
System.out.println(Inter.num2);
System.out.println("--------------");
}
}
6. 类与类:
继承关系,只能单继承,可以多层继承。
类与接口:
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系,可以单继承,也可以多继承。
interface Father {
public abstract void show();
}
interface Mother {
public abstract void show2();
}
interface Sister extends Father,Mother {
}
//class Son implements Father,Mother //多实现
class Son extends Object implements Father,Mother {
public void show() {
System.out.println("show son");
}
public void show2() {
System.out.println("show2 son");
}
}
class InterfaceDemo3 {
public static void main(String[] args) {
//创建对象
Father f = new Son();
f.show();
//f.show2(); //报错
Mother m = new Son();
//m.show(); //报错
m.show2();
}
}
8..抽象类和接口的区别:
A:成员区别
抽象类:
成员变量:可以变量,也可以常量
构造方法:有
成员方法:可以抽象,也可以非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象
B:关系区别
类与类
继承,单继承
类与接口
实现,单实现,多实现
接口与接口
继承,单继承,多继承
C:设计理念区别
抽象类 被继承体现的是:”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是:”like a”的关系。接口中定义的是该继承体系的扩展功能。
五.形式参数和返回值的问题(理解)
1. 形式参数:
基本类型(太简单,不是我今天要讲解的)
引用类型
类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
抽象类:需要的是该抽象的类子类对象
接口:需要的是该接口的实现类对象
2. 返回值类型
基本类型:(基本类型太简单,我不准备讲解)
引用类型:
类:返回的是该类的对象
抽象类:返回的是该抽象类的子类对象
接口:返回的是该接口的实现类的对象
六.修饰符的概述和总结
1. 本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
Protected Y Y Y
public Y Y Y Y
2. 修饰符:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
抽象修饰符:abstract
类:
权限修饰符:默认修饰符,public
状态修饰符:final
抽象修饰符:abstract
用的最多的就是:public
成员变量:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
用的最多的就是:private
构造方法:
权限修饰符:private,默认的,protected,public
用的最多的就是:public
成员方法:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
抽象修饰符:abstract
用的最多的就是:public
除此以外的组合规则:
成员变量:public static final
成员方法:public static
public abstract
public final
七. 内部类
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 {
private int num = 10;
//成员位置
/*
class Inner {
}
*/
public void method() {
//局部位置
class Inner {
}
}
}
class InnerClassDemo2 {
public static void main(String[] args) {
}
}
3. 成员内部类:
如何直接访问内部类的成员。
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
class Outer {
private int num = 10;
class Inner {
public void show() {
System.out.println(num);
}
}
}
class InnerClassDemo3 {
public static void main(String[] args) {
//需求:我要访问Inner类的show()方法
//Inner i = new Inner();
//i.show();
//格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
4. 成员内部类的修饰符:
private 为了保证数据的安全性
static 为了方便访问数据
注意:静态内部类访问的外部类数据必须用静态修饰。
案例:我有一个人(人有身体,身体内有心脏。)
class Body {
private class Heart {
public void operator() {
System.out.println("心脏搭桥");
}
}
public void method() {
if(如果你是外科医生) {
Heart h = new Heart();
h.operator();
}
}
}
5. 面试题:
要求请填空分别输出30,20,10。
注意:
1:内部类和外部类没有继承关系。
2:通过外部类名限定this对象
Outer.this
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
//System.out.println(new Outer().num);
System.out.println(Outer.this.num);
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
5. 局部内部类
A:可以直接访问外部类的成员
B:在局部位置,可以创建内部类对象,通过对象调用内部类方法,来使用局部内部 类功能
7. 面试题:
局部内部类访问局部变量的注意事项?
A:局部内部类访问局部变量必须用final修饰
B:为什么呢?
局部变量是随着方法的调用而调用,随着调用完毕而消失。
而堆内存的内容并不会立即消失。所以,我们加final修饰。
加入final修饰后,这个变量就成了常量。既然是常量。你消失了。
我在内存中存储的是数据20,所以,我还是有数据在使用。
*/
class Outer {
private int num = 10;
public void method() {
//int num2 = 20;
//final int num2 = 20;
class Inner {
public void show() {
System.out.println(num);
//从内部类中访问本地变量num2; 需要被声明为最终类型
System.out.println(num2);//20
}
}
//System.out.println(num2);
Inner i = new Inner();
i.show();
}
}
class InnerClassDemo5 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
8. 匿名内部类
就是内部类的简化写法。
前提:存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式:
new 类名或者接口名(){
重写方法;
}
本质是什么呢?
是一个继承了该类或者实现了该接口的子类匿名对象。
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();
}
}
9. 匿名内部类在开发中的使用
interface Person {
public abstract void study();
}
class PersonDemo {
//接口名作为形式参数
//其实这里需要的不是接口,而是该接口的实现类的对象
public void method(Person p) {
p.study();
}
}
//实现类
class Student implements Person {
public void study() {
System.out.println("好好学习,天天向上");
}
}
class InnerClassTest2 {
public static void main(String[] args) {
//测试
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
System.out.println("--------------------");
//匿名内部类在开发中的使用
//匿名内部类的本质是继承类或者实现了接口的子类匿名对象
pd.method(new Person(){
public void study() {
System.out.println("好好学习,天天向上");
}
});
}
}
10. 匿名内部类面试题:
按照要求,补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
interface Inter {
void show();
//public abstract
}
class Outer {
//补齐代码
public static Inter method() {
//子类对象 -- 子类匿名对象
return new Inter() {
public void show() {
System.out.println("HelloWorld");
}
};
}
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
/*
1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
2:Outer.method().show()可以看出method()方法的返回值是一个对象。
又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
*/
}
}