Java面向对象基础
面向对象
学习内容
-
l 面向对象思想
-
l 类与对象及其使用
-
l 对象的内存图
-
l 成员变量和局部变量的区别
-
l 匿名对象
-
l 封装(private)
-
l this关键字
-
l 构造方法
-
l static关键字
-
l 继承
-
l 多态
-
l 抽象类
-
l 接口
-
l 包和导包
-
l 权限修饰符
-
l 内部类
一、面向对象思想
l 前面我们讲过数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如获取最值，数值逆序等，同样需要将这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？通过前面的讲解我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。
面向过程思想概述
l 我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
l 在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
l 那么什么是面向过程开发呢?面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
l 面向过程的代表语言：C语言
面向对象思想概述
l 当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。接下来我们看看面向对象到底是什么?
l 面向对象思想概述
• 面向对象是基于面向过程的编程思想
l 面向对象思想特点
• 是一种更符合我们思想习惯的思想
• 可以将复杂的事情简单化
• 将我们从执行者变成了指挥者
• 角色发生了转换
面向对象思想举例
l 面向对象思想举例
• 买电脑
• 吃饭
• 洗衣服
• 万事万物皆对象
l 面向过程思想和面向对象思想的代码举例
• 把大象装进冰箱
面向对象开发,设计,特征
l 面向对象开发
• 就是不断的创建对象，使用对象，指挥对象做事情。
l 面向对象设计
• 其实就是在管理和维护对象之间的关系。
l 面向对象特征
• 封装(encapsulation)
• 继承(inheritance)
• 多态(polymorphism)
二、类与对象关系
l 我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
l 我们如何表示一个现实世界事物呢：
• 属性 就是该事物的描述信息
• 行为 就是该事物能够做什么
• 举例：学生事物
l 我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
类与对象关系
l 类：是一组相关的属性和行为的集合
l 对象：是该类事物的具体体现
l 举例：
• 类 学生
• 对象 班长就是一个对象
类与对象(图例)
l 类与对象的关系如图
类的定义
l 现实世界的事物
• 属性 人的身高，体重等
• 行为 人可以学习，吃饭等
l Java中用class描述事物也是如此
• 成员变量就是事物的属性
• 成员方法就是事物的行为
l 定义类其实就是定义类的成员(成员变量和成员方法)
类与对象案例
l 学生类
• 如何定义
• 按照事物到类的过程一步步分析
• 如何使用
• 创建对象：
• 类名 对象名= new 类名();
• 对象名.成员变量
• 对象名.成员方法
三、对象内存图
l 1个对象的内存图
• 一个对象的基本初始化过程
l 2个对象的内存图
• 方法的共用
l 3个对象的内存图
• 其中有两个引用指向同一个对象
四、成员变量和局部变量的区别
l 在类中的位置不同
• 成员变量：类中方法外
• 局部变量：方法内或者方法声明上
l 在内存中的位置不同
• 成员变量：堆内存
• 局部变量：栈内存
l 生命周期不同
• 成员变量随着对象的存在而存在，随着对象的消失而消失
• 局部变量随着方法的调用而存在，随着方法的调用完毕而消失
l 初始化值不同
• 成员变量有默认的初始化值
• 局部变量没有默认的初始化值，必须先定义，赋值，才能使用。
形式参数问题
l 基本类型作为形式参数
l 引用类型作为形式参数
-
类作为形式参数的问题
-
如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。
/*
形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
*/
//形式参数是基本类型
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
//形式参数是引用类型
class Student {
public void show() {
System.out.println("我爱学习");
}
}
class StudentDemo {
//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
s.show();
}
}
class ArgsTest {
public static void main(String[] args) {
//形式参数是基本类型的调用
Demo d = new Demo();
int result = d.sum(10,20);
System.out.println("result:"+result);
System.out.println("--------------");
//形式参数是引用类型的调用
//需求：我要调用StudentDemo类中的method()方法
StudentDemo sd = new StudentDemo();
//创建学生对象
Student s = new Student();
sd.method(s); //把s的地址给到了这里
}
}五、匿名对象
l 匿名对象：就是没有名字的对象。
• 是对象的一种简化表示形式
l 匿名对象的两种使用情况
• 对象调用方法仅仅一次的时候
• 作为实际参数传递
/*
匿名对象：就是没有名字的对象。
匿名对象的应用场景：
A:调用方法，仅仅只调用一次的时候。
注意：调用多次的时候，不适合。
那么，这种匿名调用有什么好处吗?
有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递
*/
class Student {
public void show() {
System.out.println("我爱学习");
}
}
class StudentDemo {
public void method(Student s) {
s.show();
}
}
class NoNameDemo {
public static void main(String[] args) {
//带名字的调用
Student s = new Student();
s.show();
s.show();
System.out.println("--------------");
//匿名对象
//new Student();
//匿名对象调用方法
new Student().show();
new Student().show(); //这里其实是重新创建了一个新的对象
System.out.println("--------------");
//匿名对象作为实际参数传递
StudentDemo sd = new StudentDemo();
//Student ss = new Student();
//sd.method(ss); //这里的ss是一个实际参数
//匿名对象
sd.method(new Student());
//在来一个
new StudentDemo().method(new Student());
}
}六、封装
l 封装概述
• 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
l 好处：
• 隐藏实现细节，提供公共的访问方式
• 提高了代码的复用性
• 提高安全性。
l 封装原则：
• 将不需要对外提供的内容都隐藏起来。
• 把属性隐藏，提供公共方法对其访问。
/*
定义一个学生类：
成员变量：name，age
成员方法：show()方法
我们在使用这个案例的过程中，发现了一个问题：
通过对象去给成员变量赋值，可以赋值一些非法的数据。
这是不合理的。
应该是这个样子的：在赋值之前，先对数据进行判断。
判断到底在哪里做比较合适呢?
StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。
所以，这个判断应该定义在Student类中。
而我们在成员变量的位置可不可以进行数据判断呢?
是不可以的，因为做数据校验，必须要依靠一些逻辑语句。
逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法
来对数据进行校验。
按照我们前面的分析，我们给出了一个方法进行校验。
但是呢，它偏偏不调用方法来赋值，还是直接赋值了，
这样我们的方法就没有起到作用。
我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。
怎么去强制要求不能直接使用成员变量呢?
针对这种情况，Java就提供了一个关键字 private
private:私有的。可以修饰成员变量和成员方法。
注意：被private修饰的成员只能在本类中访问。
其实我讲到现在讲解的是一个封装的思想。
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
*/
class Student {
//姓名
String name;
//年龄
private int age;
//写一个方法对数据进行校验
/*
返回值类型：void
参数列表：int a
*/
public void setAge(int a) {
if(a < 0 || age > 120) {
System.out.println("你给的年龄有问题");
}else {
age = a;
}
}
//show()方法,显示所有成员变量值
public void show() {
System.out.println("姓名："+name);
System.out.println("年龄："+age);
}
}
class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
s.show();
System.out.println("--------------");
//给成员变量赋值
s.name = "林青霞";
//s.age = 27;
s.setAge(27);
s.show();
System.out.println("--------------");
//给age赋值
//s.age = -27; //这个数据是不合理的
//通过方法给值
s.setAge(-27);
s.show();
System.out.println("--------------");
}
}private关键字
l private关键字：
• 是一个权限修饰符。
• 可以修饰成员(成员变量和成员方法)
• 被private修饰的成员只在本类中才能访问。
l private最常见的应用：
• 把成员变量用private修饰
• 提供对应的getXxx()/setXxx()方法
• 一个标准的案例的使用
/*
封装和private的应用：
A:把成员变量用private修饰
B:提高对应的getXxx()和setXxx()方法
*/
//定义学生类
class Student {
//姓名
private String name;
//年龄
private int age;
//姓名获取值
public String getName() {
return name;
}
//姓名设置值
public void setName(String n) {
name = n;
}
//年龄获取值
public int getAge() {
return age;
}
//年龄赋值
public void setAge(int a) {
age = a;
}
}
//测试类
class StudentTest {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//使用成员变量
//错误：被私有修饰了，外界不能直接访问了
//System.out.println(s.name+"---"+s.age);
System.out.println(s.getName()+"---"+s.getAge());
//给成员变量赋值
//s.name = "林青霞";
//s.age = 27;
//通过方法给赋值
s.setName("林青霞");
s.setAge(27);
System.out.println(s.getName()+"---"+s.getAge());
}
}七、this关键字
l this:代表所在类的对象引用
l 记住：
• 方法被哪个对象调用，this就代表那个对象
l 什么时候使用this呢?
• 局部变量隐藏成员变量
• 其他用法后面和super一起讲解
/*
标准的代码改进版
this:哪个对象调用那个方法，this就代表那个对象
*/
class Student {
private String name;
private int age;
public String getName() {
return name; //这里其实是隐含了this
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class StudentTest2 {
public static void main(String[] args) {
//创建一个对象
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
//创建第二个对象
Student s2 = new Student();
s2.setName("刘意");
s2.setAge(30);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}八、构造方法
l 构造方法作用概述
• 给对象的数据进行初始化
l 构造方法格式
• 方法名与类名相同
• 没有返回值类型，连void都没有
• 没有具体的返回值
| 思考题
-
构造方法中可不可以有return语句呢?
-
可以。而是我们写成这个样子就OK了：return;
-
其实，在任何的void类型的方法的最后你都可以写上：return;
l 构造方法注意事项
• 如果你不提供构造方法，系统会给出默认构造方法
• 如果你提供了构造方法，系统将不再提供
-
如果这个时候，我们要使用无参构造方法，就必须自己给出。
-
推荐：永远手动自己给出无参构造方法。
• 构造方法也是可以重载的
/*
我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?
构造方法的注意事项:
A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
给成员变量赋值有两种方式：
A:setXxx()
B:构造方法
*/
class Student {
private String name;
private int age;
public Student() {
//System.out.println("我给了，你还给不");
System.out.println("这是无参构造方法");
}
//构造方法的重载格式
public Student(String name) {
System.out.println("这是带一个String类型的构造方法");
this.name = name;
}
public Student(int age) {
System.out.println("这是带一个int类型的构造方法");
this.age = age;
}
public Student(String name,int age) {
System.out.println("这是一个带多个参数的构造方法");
this.name = name;
this.age = age;
}
public void show() {
System.out.println(name+"---"+age);
}
}
class ConstructDemo2 {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
System.out.println("-------------");
//创建对象2
Student s2 = new Student("林青霞");
s2.show();
System.out.println("-------------");
//创建对象3
Student s3 = new Student(27);
s3.show();
System.out.println("-------------");
//创建对象4
Student s4 = new Student("林青霞",27);
s4.show();
}
}类的成员方法
l 成员方法其实就是我们前面讲过的方法
l 方法具体划分：
• 根据返回值
• 有明确返回值方法
• 返回void类型的方法
• 根据形式参数
• 无参方法
• 带参方法
一个基本类的标准代码写法
l 类
• 成员变量
• 构造方法
• 无参构造方法
• 带参构造方法
• 成员方法
• getXxx()
• setXxx()
l 给成员变量赋值的方式
l 无参构造方法+setXxx()
l 带参构造方法
一个基本类的标准代码案例
l 标准的学生类(讲解)
• 感觉调用getXxx()输出学生信息比较麻烦，加入一个方法show()，输出学生对象的成员变量信息。
class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age) {
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 StudentDemo {
public static void main(String[] args) {
//方式1
Student s1 = new Student();
s1.setName("Tom");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
//方式2
Student s2 = new Student("Jam",30);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}l 注意
• 目前的代码是为了练习的一种标准格式
• 给成员变量赋值有两种方式，可以只写一种
• 如果不单独获取数据，可以不写getXxx()方法
类的初始化过程
l Student s = newStudent();在内存中做了哪些事情?
• 加载Student.class文件进内存
• 在栈内存为s开辟空间
• 在堆内存为学生对象开辟空间
• 对学生对象的成员变量进行默认初始化
• 对学生对象的成员变量进行显示初始化
• 通过构造方法对学生对象的成员变量赋值
• 学生对象初始化完毕，把对象地址赋值给s变量
面向对象练习
l 定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试了Test，进行测试。
l 定义一个长方形类,定义求周长和面积的方法，然后定义一个测试了Test2，进行测试。
l 定义一个员工类,自己分析出几个成员，然后给出成员变量，构造方法，getXxx()/setXxx()方法，以及一个显示所有成员信息的方法。并测试。
l 定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
九、static关键字
l 可以修饰成员变量和成员方法
l static关键字特点
• 随着类的加载而加载
• 优先于对象存在
• 被类的所有对象共享
• 这也是我们判断是否使用静态关键字的条件
• 可以通过类名调用：既可以通过对象名调用，也可以通过类名调用，建议通过类名调用
l static关键字注意事项
• 在静态方法中是没有this关键字的
• 静态方法只能访问静态的成员变量和静态的成员方法
/*
static关键字注意事项
A:在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
简单记：
静态只能访问静态。
*/
class Teacher {
public int num = 10;
public static int num2 = 20;
public void show() {
System.out.println(num); //隐含的告诉你访问的是成员变量
System.out.println(this.num); //明确的告诉你访问的是成员变量
System.out.println(num2);
//function();
//function2();
}
public static void method() {
//无法从静态上下文中引用非静态 变量 num
//System.out.println(num);
System.out.println(num2);
//无法从静态上下文中引用非静态 方法 function()
//function();
function2();
}
public void function() {
}
public static void function2() {
}
}
class TeacherDemo {
public static void main(String[] args) {
//创建对象
Teacher t = new Teacher();
t.show();
System.out.println("------------");
t.method();
}
}静态的内存图
l 静态的内容存在于方法区的静态区
静态变量和成员变量的区别
l 所属不同
• 静态变量属于类，所以也称为为类变量
• 成员变量属于对象，所以也称为实例变量(对象变量)
l 内存中位置不同
• 静态变量存储于方法区的静态区
• 成员变量存储于堆内存
l 内存出现时间不同
• 静态变量随着类的加载而加载，随着类的消失而消失
• 成员变量随着对象的创建而存在，随着对象的消失而消失
l 调用不同
• 静态变量可以通过类名调用，也可以通过对象调用
• 成员变量只能通过对象名调用
main方法是静态的
l public static voidmain(String[] args) {}
• public 被jvm调用，访问权限足够大。
• static 被jvm调用，不用创建对象，直接类名访问
• void被jvm调用，不需要给jvm返回值
• main 一个通用的名称，虽然不是关键字，但是被jvm识别
• String[] args以前用于接收键盘录入的
• 演示案例
/*
main方法的格式讲解：
public static void main(String[] args) {...}
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。我见过的语言都是以main作为入口。
String[] args:这是一个字符串数组。值去哪里了?
这个东西到底有什么用啊?怎么给值啊?
这个东西早期是为了接收键盘录入的数据的。
格式是：
java MainDemo hello world java
*/
class MainDemo {
public static void main(String[] args) {
//System.out.println(args); //[Ljava.lang.String;@175078b
//System.out.println(args.length); //0
//System.out.println(args[0]); //ArrayIndexOutOfBoundsException
//接收数据后
System.out.println(args);
System.out.println(args.length);
//System.out.println(args[0]);
for(int x=0; x制作帮助文档
l 制作工具类
• ArrayTools
l 制作帮助文档(API)
• javadoc -d 目录 -author -version ArrayTool.java
class ArrayTool {
//把构造方法私有，外界就不能在创建对象了
private ArrayTool(){}
public static void printArray(int[] arr) {
for(int x=0; x如何使用帮助文档
l 找到文档，打开文档
l 点击显示，找到索引，出现输入框
l 你应该知道你找谁?举例：Scanner
l 看这个类的结构(需不需要导包)
• 成员变量字段
• 构造方法构造方法
• 成员方法方法
l 看这个类的说
l 看构造方法
l 看成员方法
l 然后使用
通过API学习Math类
l Math类概述
• Math包含用于执行基本数学运算的方法
l Math类特点
• 没有构造方法，因为成员都是静态的
l Math类讲解一个方法
• 获取随机数
-
public static double random(): [0.0,1.0)
• 获取1-100之间的随机数
-
int number = (int)(Math.random()*100)+1;
l 案例：
• 猜数字小游戏
代码块
l 代码块
• 在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
• 局部代码块
• 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
• 构造代码块
• 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
• 静态代码块在类中方法外出现，加了static修饰
• 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。
/*
代码块：在Java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为
局部代码块:局部位置,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用：一般是对类进行初始化。
面试题?
静态代码块,构造代码块,构造方法的执行顺序?
静态代码块 -- 构造代码块 -- 构造方法
静态代码块：只执行一次
构造代码块：每次调用构造方法都执行
*/
class Code {
static {
int a = 1000;
System.out.println(a);
}
//构造代码块
{
int x = 100;
System.out.println(x);
}
//构造方法
public Code(){
System.out.println("code");
}
//构造方法
public Code(int a){
System.out.println("code");
}
//构造代码块
{
int y = 200;
System.out.println(y);
}
//静态代码块
static {
int b = 2000;
System.out.println(b);
}
}
class CodeDemo {
public static void main(String[] args) {
//局部代码块
{
int x = 10;
System.out.println(x);
}
//找不到符号
//System.out.println(x);
{
int y = 20;
System.out.println(y);
}
System.out.println("---------------");
Code c = new Code();
System.out.println("---------------");
Code c2 = new Code();
System.out.println("---------------");
Code c3 = new Code(1);
}
}进阶内容
l 继承
l 多态
l 抽象类
l 接口
l 包和导包
l 权限修饰符
l 内部类
十、继承
l 继承概述
• 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
• 通过extends关键字可以实现类与类的继承
• class 子类名 extends 父类名{}
• 单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
• 有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。
继承的好处
l 继承的好处
• 提高了代码的复用性
• 多个类相同的成员可以放到同一个类中
• 提高了代码的维护性
• 如果功能的代码需要修改，修改一处即可
• 让类与类之间产生了关系，是多态的前提
• 其实这也是继承的一个弊端：类的耦合性很强
-
让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
-
原则：低耦合，高内聚。
-
耦合：类与类的关系
-
内聚：自己完成某件事情的能力
Java中继承的特点
l Java只支持单继承，不支持多继承。
• 一个类只能有一个父类，不可以有多个父类。
• class SubDemo extendsDemo{} //ok
• class SubDemo extendsDemo1,Demo2...//error
l Java支持多层继承(继承体系)
• class A{}
• class B extends A{}
• class C extends B{}
Java中继承的注意事项
l 子类只能继承父类所有非私有的成员(成员方法和成员变量)
• 其实这也体现了继承的另一个弊端：打破了封装性
l 子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。
l 不要为了部分功能而去继承
l 我们到底在什么时候使用继承呢?
• 继承中类之间体现的是：”isa”的关系。
继承中成员变量的关系
l 案例演示
• 子父类中同名和不同名的成员变量
l 结论：
• 在子类方法中访问一个变量
• 首先在子类局部范围找
• 然后在子类成员范围找
• 最后在父类成员范围找(肯定不能访问到父类局部范围)
• 如果还是没有就报错。(不考虑父亲的父亲…)
super关键字
l super的用法和this很像
• this代表本类对应的引用。
• super代表父类存储空间的标识(可以理解为父类引用)
l 用法(this和super均可如下使用)
-
l 访问成员变量
-
this.成员变量 super.成员变量
-
l 访问构造方法(子父类的构造方法问题讲)
-
this(…) super(…)
-
l 访问成员方法(子父类的成员方法问题讲)
-
this.成员方法() super.成员方法()
/*
问题是：
我不仅仅要输出局部范围的num，还要输出本类成员范围的num。怎么办呢?
我还想要输出父类成员范围的num。怎么办呢?
如果有一个东西和this相似，但是可以直接访问父类的数据就好了。
恭喜你，这个关键字是存在的：super。
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();
}
}继承中构造方法的关系
l 子类中所有的构造方法默认都会访问父类中空参数的构造方法
l 为什么呢?
• 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
• 每一个构造方法的第一条语句默认都是：super()
/*
继承中构造方法的关系
A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
B:为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
注意：子类每一个构造方法的第一条语句默认都是：super();
*/
class Father {
int age;
public Father() {
System.out.println("Father的无参构造方法");
}
public Father(String name) {
System.out.println("Father的带参构造方法");
}
}
class Son extends Father {
public Son() {
//super();
System.out.println("Son的无参构造方法");
}
public Son(String name) {
//super();
System.out.println("Son的带参构造方法");
}
}
class ExtendsDemo6 {
public static void main(String[] args) {
//创建对象
Son s = new Son();
System.out.println("------------");
Son s2 = new Son("林青霞");
}
}继承中构造方法的关系
l 如何父类中没有构造方法，该怎么办呢?
• 子类通过super去显示调用父类其他的带参的构造方法
• 子类通过this去调用本类的其他构造方法
• 本类其他构造也必须首先访问了父类构造
• 一定要注意：
• super(…)或者this(….)必须出现在第一条语句上
• 否则，就会有父类数据的多次初始化
/*
如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?
报错。
如何解决呢?
A:在父类中加一个无参构造方法
B:通过使用super关键字去显示的调用父类的带参构造方法
C:子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。
注意事项：
this(...)或者super(...)必须出现在第一条语句上。
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。
*/
class Father {
/*
public Father() {
System.out.println("Father的无参构造方法");
}
*/
public Father(String name) {
System.out.println("Father的带参构造方法");
}
}
class Son extends Father {
public Son() {
super("随便给");
System.out.println("Son的无参构造方法");
//super("随便给");
}
public Son(String name) {
//super("随便给");
this();
System.out.println("Son的带参构造方法");
}
}
class ExtendsDemo7 {
public static void main(String[] args) {
Son s = new Son();
System.out.println("----------------");
Son ss = new Son("林青霞");
}
}继承中成员方法的关系
l 案例演示
• 子父类中同名和不同名的成员方法
l 结论：
• 通过子类对象去访问一个方法
• 首先在子类中找
• 然后在父类中找
• 如果还是没有就报错。(不考虑父亲的父亲…)
继承中成员方法的关系
l 方法重写概述
• 子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。
• 使用特点：
• 如果方法名不同，就调用对应的方法
• 如果方法名相同，最终使用的是子类自己的
l 方法重写的应用：
• 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
*
方法重写：子类中出现了和父类中方法声明一模一样的方法。
方法重载：
本类中出现的方法名一样，参数列表不同的方法。与返回值无关。
子类对象调用方法的时候：
先找子类本身，再找父类。
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
案例：
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("林青霞");
}
}继承中成员方法的关系
l 方法重写的注意事项
• 父类中私有方法不能被重写
• 子类重写父类方法时，访问权限不能更低
• 父类静态方法，子类也必须通过静态方法进行重写。(其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中会讲解)
/*
方法重写的注意事项
A:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B:子类重写父类方法时，访问权限不能更低
最好就一致
C:父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
子类重写父类方法的时候，最好声明一模一样。
*/
class Father {
//private void show() {}
/*
public void show() {
System.out.println("show Father");
}
*/
void show() {
System.out.println("show Father");
}
/*
public static void method() {
}
*/
public void method() {
}
}
class Son extends Father {
//private void show() {}
/*
public void show() {
System.out.println("show Son");
}
*/
public void show() {
System.out.println("show Son");
}
public static void method() {
}
/*
public void method() {
}
*/
}
class ExtendsDemo10 {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}两个面试题
l 方法重写和方法重载的区别?方法重载能改变返回值类型吗?
• Overload：方法重载
• Override：方法重写
-
方法重写：在子类中，出现和父类中一模一样的方法声明的现象。
-
方法重载：同一个类中，出现的方法名相同，参数列表不同的现象。
-
方法重载能改变返回值类型，因为它和返回值类型无关。
l this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
/*
看程序写结果：
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();
}
}继承练习
-
数据初始化的面试题
-
A:一个类的初始化过程
-
B:子父类的构造执行过程
-
C:分层初始化
/*
看程序写结果：
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();
}
}final关键字
l final关键字是最终的意思，可以修饰类，成员变量，成员方法。
• 修饰类，类不能被继承
• 修饰变量，变量就变成了常量，只能被赋值一次
• 修饰方法，方法不能被重写
/*
final可以修饰类，方法，变量
特点：
final可以修饰类，该类不能被继承。
final可以修饰方法，该方法不能被重写。(覆盖，复写)
final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。
常量：
A:字面值常量
"hello",10,true
B:自定义常量
final int x = 10;
*/
//final class Fu //无法从最终Fu进行继承
class Fu {
public int num = 10;
public final int num2 = 20;
/*
public final void show() {
}
*/
}
class Zi extends Fu {
// Zi中的show()无法覆盖Fu中的show()
public void show() {
num = 100;
System.out.println(num);
//无法为最终变量num2分配值
//num2 = 200;
System.out.println(num2);
}
}
class FinalDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}l final关键字面试题
• final修饰局部变量
• 在方法内部，该变量不可以被改变
• 在方法声明上，分别演示基本类型和引用类型作为参数的情况
• 基本类型，是值不能被改变
• 引用类型，是地址值不能被改变
/*
面试题：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();
}
}• final修饰变量的初始化时机
• 在对象构造完毕前即可
/*
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);
}
}
十一、多态
l 多态概述
• 某一个事物，在不同时刻表现出来的不同状态。
• 举例：
• 猫可以是猫的类型。猫 m = new 猫();
• 同时猫也是动物的一种，也可以把猫称为动物。
• 动物 d = new 猫();
• 在举一个例子：水在不同时刻的状态
l 多态前提和体现
• 有继承关系或者实现关系
• 有方法重写
• 有父类或者父类接口引用指向子类对象
| 多态的分类
具体类多态
-
class Fu {}
-
class Zi extends Fu {}
-
Fu f = new Zi();
抽象类多态
-
abstract class Fu {}
-
class Zi extends Fu {}
-
Fu f = new Zi();
接口多态
-
interface Fu {}
-
class Zi implements Fu {}
-
Fu f = new Zi();
多态案例及成员访问特点
l 多态案例
• 按照前提写一个多态的案例
l 成员访问特点
l 成员变量
l 编译看左边，运行看左边
| 构造方法
| 子类的构造都会默认访问父类构造
l 成员方法
l 编译看左边，运行看右边
l 静态方法
l 编译看左边，运行看左边
l 所以前面静态方法不能算方法的重写
多态的好处和弊端
l 多态的好处
• 提高了程序的维护性(由继承保证)
• 提高了程序的扩展性(由多态保证)
l 多态的弊端
• 不能访问子类特有功能
• 那么我们如何才能访问子类的特有功能呢?
• 多态中的转型
多态中的转型问题
l 向上转型
• 从子到父
• 父类引用指向子类对象
l 向下转型
• 从父到子
• 父类引用转为子类对象
/*
多态的弊端：
不能使用子类的特有功能。
我就想使用子类的特有功能?行不行?
行。
怎么用呢?
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();
}
}多态练习
/*
看程序写结果:先判断有没有问题，如果没有，写出结果
多态的成员访问特点：
方法：编译看左边，运行看右边。
继承的时候：
子类中有和父类中一样的方法，叫重写。
子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
class A {
public void show() {
show2();
}
public void show2() {
System.out.println("我");
}
}
class B extends A {
/*
public void show() {
show2();
}
*/
public void show2() {
System.out.println("爱");
}
}
class C extends B {
public void show() {
super.show();
}
public void show2() {
System.out.println("你");
}
}
public class DuoTaiTest4 {
public static void main(String[] args) {
A a = new B();
a.show();
B b = new C();
b.show();
}
}十二、抽象类
l 抽象类概述
• 回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。
为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
抽象类概述
l 抽象类概述
• 回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。
为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
抽象类特点
l 抽象类特点
• 抽象类和抽象方法必须用abstract关键字修饰
• 格式
• abstract class 类名{}
• public abstract void eat();
• 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
• 抽象类不能实例化
• 那么，抽象类如何实例化呢?
• 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
• 抽象类的子类
• 要么是抽象类
• 要么重写抽象类中的所有抽象方法
抽象类的成员特点
l 成员变量
• 可以是变量
• 也可以是常量
l 构造方法
• 有构造方法，但是不能实例化
• 那么，构造方法的作用是什么呢?
• 用于子类访问父类数据的初始化
l 成员方法
• 可以有抽象方法限定子类必须完成某些动作
• 也可以有非抽象方法提高代码服用性
抽象类练习
l 猫狗案例
• 具体事物：猫，狗
• 共性：姓名，年龄，吃饭
l 老师案例
• 具体事物：基础班老师，就业班老师
• 共性：姓名，年龄，讲课。
l 学生案例
• 具体事务：基础班学员，就业班学员
• 共性：姓名，年龄，班级，学习，吃饭
l 员工案例(备注部分)
抽象类的几个小问题
l 一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
l abstract不能和哪些关键字共存
• private 冲突
• final 冲突
• static 无意义
/*
一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
A:可以。
B:不让创建对象。
abstract不能和哪些关键字共存?
private 冲突
final 冲突
static 无意义
*/
abstract class Fu {
//public abstract void show();
//非法的修饰符组合: abstract和private
//private abstract void show();
//非法的修饰符组合
//final abstract void show();
//非法的修饰符组合
static abstract void show();
public static void method() {
System.out.println("method");
}
}
class Zi extends Fu {
public void show() {}
}
class AbstractDemo3 {
public static void main(String[] args) {
Fu.method();
}
}十三、接口
l 接口概述
• 继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了，对不。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的，对不。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。
接口特点
l 接口特点
• 接口用关键字interface表示
• 格式：interface 接口名{}
• 类实现接口用implements表示
• 格式：class 类名 implements 接口名{}
• 接口不能实例化
• 那么，接口如何实例化呢?
• 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。
• 接口的子类
• 要么是抽象类
• 要么重写接口中的所有抽象方法
接口成员特点
l 成员变量
• 只能是常量
• 默认修饰符public static final
l 构造方法
• 没有，因为接口主要是扩展功能的，而没有具体存在
l 成员方法
• 只能是抽象方法
• 默认修饰符public abstract
/*
接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：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("--------------");
}
}类与类,类与接口以及接口与接口的关系
l 类与类
• 继承关系，只能单继承，但是可以多层继承
l 类与接口
• 实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
l 接口与接口
• 继承关系，可以单继承，也可以多继承
/*
类与类：
继承关系,只能单继承,可以多层继承。
类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系,可以单继承,也可以多继承。
*/
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();
}
}抽象类和接口的区别
l 成员区别
• 抽象类变量,常量;有抽象方法;抽象方法,非抽象方法
• 接口常量;抽象方法
l 关系区别
• 类与类继承，单继承
• 类与接口实现，单实现，多实现
• 接口与接口继承，单继承，多继承
l 设计理念区别
• 抽象类被继承体现的是：”is a”的关系。共性功能
• 接口被实现体现的是：”like a”的关系。扩展功能
接口练习
l 猫狗案例,加入跳高的额外功能
l 老师和学生案例,加入抽烟的额外功能
/*
猫狗案例,加入跳高的额外功能
分析：从具体到抽象
猫：
姓名,年龄
吃饭，睡觉
狗：
姓名,年龄
吃饭，睡觉
由于有共性功能，所以，我们抽取出一个父类：
动物：
姓名,年龄
吃饭();
睡觉(){}
猫：继承自动物
狗：继承自动物
跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
接口：
跳高
部分猫：实现跳高
部分狗：实现跳高
实现；
从抽象到具体
使用：
使用具体类
*/
//定义跳高接口
interface Jumpping {
//跳高功能
public abstract void jump();
}
//定义抽象类
abstract class Animal {
//姓名
private String name;
//年龄
private int age;
public Animal() {}
public Animal(String name,int age) {
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;
}
//吃饭();
public abstract void eat();
//睡觉(){}
public void sleep() {
System.out.println("睡觉觉了");
}
}
//具体猫类
class Cat extends Animal {
public Cat(){}
public Cat(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("猫吃鱼");
}
}
//具体狗类
class Dog extends Animal {
public Dog(){}
public Dog(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("狗吃肉");
}
}
//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
public JumpCat() {}
public JumpCat(String name,int age) {
super(name,age);
}
public void jump() {
System.out.println("跳高猫");
}
}
//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
public JumpDog() {}
public JumpDog(String name,int age) {
super(name,age);
}
public void jump() {
System.out.println("跳高狗");
}
}
class InterfaceTest {
public static void main(String[] args) {
//定义跳高猫并测试
JumpCat jc = new JumpCat();
jc.setName("哆啦A梦");
jc.setAge(3);
System.out.println(jc.getName()+"---"+jc.getAge());
jc.eat();
jc.sleep();
jc.jump();
System.out.println("-----------------");
JumpCat jc2 = new JumpCat("加菲猫",2);
System.out.println(jc2.getName()+"---"+jc2.getAge());
jc2.eat();
jc2.sleep();
jc2.jump();
//定义跳高狗并进行测试的事情自己完成。
}
}形式参数和返回值问题案例
l 形式参数
• 基本类型
• 引用类型
/*
形式参数：
基本类型(太简单)
引用类型
类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
抽象类:需要的是该抽象的类子类对象
接口
*/
abstract class Person {
public abstract void study();
}
class PersonDemo {
public void method(Person p) {//p; p = new Student(); Person p = new Student(); //多态
p.study();
}
}
//定义一个具体的学生类
class Student extends Person {
public void study() {
System.out.println("Good Good Study,Day Day Up");
}
}
class PersonTest {
public static void main(String[] args) {
//目前是没有办法的使用的
//因为抽象类没有对应的具体类
//那么，我们就应该先定义一个具体类
//需求：我要使用PersonDemo类中的method()方法
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
}
}l 返回值类型
• 基本类型
• 引用类型
/*
返回值类型
基本类型:(基本类型太简单)
引用类型：
类:返回的是该类的对象
抽象类:返回的是该抽象类的子类对象
接口:返回的是该接口的实现类的对象
*/
//定义一个爱好的接口
interface Love {
public abstract void love();
}
class LoveDemo {
public Love getLove() {
//Love l = new Teacher();
//return l;
return new Teacher();
}
}
//定义具体类实现接口
class Teacher implements Love {
public void love() {
System.out.println("老师爱学生,爱Java,爱林青霞");
}
}
class TeacherTest2 {
public static void main(String[] args) {
//如何测试呢?
LoveDemo ld = new LoveDemo();
Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态
l.love();
}
}l 链式编程
-
对象.方法1().方法2().......方法n();
-
这种用法：其实在方法1()调用完毕后，应该一个对象；
-
方法2()调用完毕后，应该返回一个对象。
-
方法n()调用完毕后，可能是对象，也可以不是对象。
/*
链式编程。
每次调用完毕方法后，返回的是一个对象。
*/
class Student {
public void study() {
System.out.println("Good Good Study,Day Day Up");
}
}
class StudentDemo {
public Student getStudent() {
return new Student();
}
}
class StudentTest3 {
public static void main(String[] args) {
//如何调用的呢?
StudentDemo sd = new StudentDemo();
//Student s = sd.getStudent();
//s.study();
//大家注意了
sd.getStudent().study();
}
}十四、包
l 包的概述
• 其实就是文件夹
• 作用：对类进行分类管理
-
A:区分同名的类
-
B:对类进行分类管理
-
a:按照功能分
-
b:按照模块分
• 包的划分：
• 举例：
• 学生的增加，删除，修改，查询
• 老师的增加，删除，修改，查询
• 以及以后可能出现的其他的类的增加，删除，修改，查询
• 基本的划分：按照模块和功能分。
• 高级的划分：做项目的时候就能看到了。
包的定义及注意事项
l 定义包的格式
• package 包名;
• 多级包用.分开即可
• 注意事项：
• package语句必须是程序的第一条可执行的代码
• package语句在一个java文件中只能有一个
• 如果没有package，默认表示无包名
带包的类的编译和运行
l 手动式
• a:javac编译当前类文件。
• b:手动建立包对应的文件夹。
• c:把a步骤的class文件放到b步骤的最终文件夹下。
• d:通过java命令执行。注意了：需要带包名称的执行
• java cn.itcast.HelloWorld
l 自动式
• a:javac编译的时候带上-d即可
• javac -d .HelloWorld.java
• b:通过java命令执行。和手动式一样
不同包下类之间的访问
l 定义两个类：Demo,Test。
• Demo
• 求和方法(sum)
• Test
• 测试方法(main)
导包
l 导包概述
• 不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。
l 导包格式
• import 包名;
• 注意：
• 这种方式导入是到类的名称。
• 虽然可以最后写*，但是不建议。
l package,import,class有没有顺序关系(面试题)
-
package > import > class
/*
Test类，测试
导包：
格式：import 包名;
这种方式导入是到类的名称。
注意：我们用谁就导谁。
面试题：
package,import,class有没有顺序关系?
有。
package > import > class
Package:只能有一个
import:可以有多个
class:可以有多个，以后建议是一个
*/
package cn.itcast;
import com.liuyi.Demo;
class Test {
public static void main(String[] args) {
//Demo d = new Demo();
/*
com.liuyi.Demo d = new com.liuyi.Demo();
System.out.println(d.sum(10,20));
com.liuyi.Demo d2 = new com.liuyi.Demo();
System.out.println(d2.sum(10,20));
com.liuyi.Demo d3 = new com.liuyi.Demo();
System.out.println(d3.sum(10,20));
com.liuyi.Demo d4 = new com.liuyi.Demo();
System.out.println(d4.sum(10,20));
*/
Demo d = new Demo();
System.out.println(d.sum(10,20));
}
}
/*
第一个问题：找不到Demo
第二个问题：程序包com.liuyi不存在
第三个问题： Demo在com.liuyi中不是公共的; 无法从外部程序包中对其进行访问
*/十五、权限修饰符
类及其组成可以用的修饰符
l 类：
• 默认，public，final，abstract
• 我们自己定义：public居多
l 成员变量：
• 四种权限修饰符均可,final,static
• 我们自己定义：private居多
l 构造方法：
• 四种权限修饰符均可,其他不可
• 我们自己定义：public 居多
l 成员方法：
• 四种权限修饰符均可，fianl,static,abstract
• 我们自己定义：public居多
/*
修饰符：
权限修饰符：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
*/
//此处不允许使用修饰符private
//此处不允许使用修饰符protected
//此处不允许使用修饰符static
public class Demo {
//成员变量
private int x = 10;
int y = 20;
protected int z = 30;
public int a = 40;
public final int b = 50;
public static int c = 60;
public static final int d = 70;
//此处不允许使用修饰符abstract
//abstract int e = 80;
//构造方法
private Demo(){}
Demo(String name){}
protected Demo(String name,int age) {}
public Demo(String name,int age,String address) {}
//此处不允许使用修饰符static
//public static Demo(){}
//此处不允许使用修饰符final
//public final Demo() {}
//此处不允许使用修饰符abstract
//public abstract Demo(){}
//成员方法
//static void show() {}
//abstract void show();
//final void show(){}
}十六、内部类
l 把类定义在其他类的内部，这个类就被称为内部类。
• 举例：在类A中定义了一个类B，类B就是内部类。
l 内部类的访问特点：
• 内部类可以直接访问外部类的成员，包括私有。
• 外部类要访问内部类的成员，必须创建对象。
/*
内部类概述:
把类定义在其他类的内部，这个类就被称为内部类。
举例：在类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();
}
}
class InnerClassDemo {
public static void main(String[] args) {
}
}内部类位置
l 按照内部类在类中定义的位置不同，可以分为如下两种格式：
• 成员位置(成员内部类)
• 局部位置(局部内部类)
/*
内部类位置
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。
成员位置:在成员位置定义的类，被称为成员内部类。
*/
class Outer {
private int num = 10;
//成员位置
/*
class Inner {
}
*/
public void method() {
//局部位置
class Inner {
}
}
}
class InnerClassDemo2 {
public static void main(String[] args) {
}
}l 成员内部类
l 外界如何创建对象
l 外部类名.内部类名对象名= 外部类对象.内部类对象;
/*
成员内部类:
如何直接访问内部类的成员。
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
*/
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();
}
}成员内部类
l 刚才我们讲解过了，成员内部类的使用，但是一般来说，在实际开发中是不会这样使用的。因为一般内部类就是不让外界直接访问的。
• 举例讲解这个问题：Body和Heart，电脑和CPU。
l 成员内部的常见修饰符
• private 为了保证数据的安全性
• static 为了让数据访问更方便
• 被静态修饰的成员内部类只能访问外部类的静态成员
• 内部类被静态修饰后的方法
• 静态方法
• 非静态方法
/*
成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意：静态内部类访问的外部类数据必须用静态修饰。
案例：我有一个人(人有身体，身体内有心脏。)
class Body {
private class Heart {
public void operator() {
System.out.println("心脏搭桥");
}
}
public void method() {
if(如果你是外科医生) {
Heart h = new Heart();
h.operator();
}
}
}
按照我们刚才的讲解，来使用一下
Body.Heart bh = new Body().new Heart();
bh.operator();
//加了private后，就不能被访问了，那么，怎么玩呢?
Body b = new Body();
b.method();
*/
class Outer {
private int num = 10;
private static int num2 = 100;
//内部类用静态修饰是因为内部类可以看出是外部类的成员
public static class Inner {
public void show() {
//System.out.println(num);
System.out.println(num2);
}
public static void show2() {
//System.out.println(num);
System.out.println(num2);
}
}
}
class InnerClassDemo4 {
public static void main(String[] args) {
//使用内部类
// 限定的新静态类
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
//oi.show2();
//成员内部类被静态修饰后的访问方式是:
//格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2();
//show2()的另一种调用方式
Outer.Inner.show2();
}
}
成员内部类面试题
l 补齐程序(注意:内部类和外部类没有继承关系)
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(?);
System.out.println(??);
System.out.println(???);
}
}
}
在控制分别输出：30，20，10
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
局部内部类
l 可以直接访问外部类的成员
l 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
l 局部内部类访问局部变量的注意事项：
• 必须被final修饰?
• 为什么呢?
• 因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。通过反编译工具可以看一下。
/*
局部内部类
A:可以直接访问外部类的成员
B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
面试题：
局部内部类访问局部变量的注意事项?
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();
}
}匿名内部类
l 就是内部类的简化写法。
l 前提：存在一个类或者接口
• 这里的类可以是具体类也可以是抽象类。
l 格式：
new类名或者接口名(){重写方法;}
l 本质：
• 是一个继承了类或者实现了接口的子类匿名对象
/*
匿名内部类
就是内部类的简化写法。
前提：存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式：
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();
}
}匿名内部类案例
l 写案例，并测试
• 如何调用方法
• 加入方法有多个，如何调用呢?
• 方式1：每一种格式调用一个，太麻烦
• 方式2：用类或者接口接收该子类对象，多态思想
匿名内部类在开发中的使用
l 首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，重点是接口的情况，我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，所以，可以使用匿名内部类改进以前的做法。
/*
匿名内部类在开发中的使用
*/
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("好好学习,天天向上");
}
});
}
}匿名内部类面试题
l 按照要求，补齐代码
interface Inter { void show(); }
class Outer { //补齐代码}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
/*
匿名内部类面试题：
按照要求，补齐代码
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()方法的返回值类型是一个接口。
*/
}
}