1.封装
1.1概述,作用,好处:
//封装:隐藏对象的属性和实现细节(方法),对外提供公有的访问方式,方法由我提供的,别人不能乱修改,提高代码的安全性记忆!原则//记忆
将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。
1.2 封装的步骤
-
使用
private关键字来修饰成员变量。 -
对需要访问的成员变量，提供对应的一对
getXxx方法 、setXxx方法。
1.3 封装的操作——private关键字
private的含义
-
private是一个权限修饰符，代表最小权限。
-
可以修饰成员变量和成员方法。
-
被private修饰后的成员变量和成员方法，只在本类中才能访问。
private的使用格式
private 数据类型 变量名 ；-
使用
private修饰成员变量，代码如下：
public class Student {
private String name;
private int age;
}-
提供
getXxx方法 /setXxx方法，可以访问成员变量，代码如下：
public class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
}1.4 封装优化1——this关键字
我们发现 setXxx 方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意了呢？代码如下：
public class Student {
private String name;//私有,仅仅在本类中被访问
private int age;
public void setName(String name) {//公有,哪里都可以访问
name = name;//给成员变量name赋值不成功
//原因:使用变量遵循这么一个就近原则,局部变量有就使用局部变量的,否则使用成员变量的,导致成员变量名被隐藏
}
public void setAge(int age) {
age = age;
}
}经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了setXxx() 的形参变量名后，方法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，使用变量遵循这么一个就近原则,局部变量有就使用局部变量的,否则使用成员变量的,导致成员变量名被隐藏，方法中的变量名，无法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字，来解决这个重名问题。
this的含义,this关键字代表对象的引用存的是调用方法的对象的地址值,通过地址值找到地对象,就可以点来调用拿到对象里面的成员变量给成员变量赋值
this代表所在类的当前对象的引用（地址值），即对象自己的引用(对象名)。
记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。
this使用格式
this.成员变量名；使用 this 修饰方法中的变量，解决成员变量被局部变量隐藏的问题，代码如下：
public class Student {
private String name;//成员变量属于对象里面的
private int age;
public void setName(String name) {
//name = name;
this.name = name;//this,地址值找到对象.里面的成员变量
}
public String getName() {
return name;
}
public void setAge(int age) {
//age = age;
this.age = age;
}
public int getAge() {
return age;//其实这里是this.age,隐藏了不写也是写,系统给你写
}
}小贴士：方法中只有一个变量名时，默认也是使用
this修饰，可以省略不写。
1.5 封装优化2——构造方法,创建对象一定会调用到new关键字构造方法,跑到构造方法{}里面,比如给对象的成员变量进行赋值
当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。
小贴士：无论你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。
构造方法(构造器,构造对象用的东西)的定义格式
修饰符 构造方法名(参数列表){
// 方法体
}构造方法的特点:方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void,但是可以return;结束构造方法回到main方法的出口结束程序//记忆。使用构造方法后，代码如下：
public class Student {
private String name;
private int age;
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {//构造方法作用创建对象调用到构造方法,我就可以里面给对象的成员变量进行赋值,初始化
this.name = name;
this.age = age;
}
public void Student(){//普通成员方法
//代码
}
}注意事项//记忆,创建对象一定会调用到new关键字构造方法
-
如果你不提供构造方法，系统会给出无参数构造方法。
-
如果你提供了构造方法，系统将不再提供无参数构造方法。
-
构造方法是可以重载的，既可以定义参数，也可以不定义参数。
2. 继承
2.1 概述:
多个类中存在相同属性(成员变量模拟)和行为(成员方法模拟)时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：
其中，多个类可以称为子类(或派生类)，单独那一个类称为父类、超类（superclass）或者基类。
继承描述的是事物之间的所属关系，这种关系是：is-a 的关系(谁是谁的一种)。例如，图中兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。
定义//记忆
-
继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性(成员变量)和行为(成员方法)。
好处//记忆
-
提高代码的复用性(少写了很多代码实现一样的功能),代码重用
-
类与类之间产生了关系，是多态的前提
弊端(有可能引发的问题):类的耦合性加强了//面试可能问,建议记忆一下
开发中的原则:高内聚,低耦合,一般的,如果一个类能自己干的,就不要跟其他的类发生过多的关系 内聚:就是类自己独立完成某件事情的能力 耦合:就是类与类之间的关系(万一其中一个类写坏了,其他类也坏了)
2.2 继承的格式
通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：
class 父类 {
...
}
class 子类 extends 父类 {
...
}
继承演示，代码如下：
/*
* 定义员工类Employee，做为父类
*/
class Employee {
String name; // 定义name属性
// 定义员工的工作方法
public void work() {
System.out.println("尽心尽力地工作");
}
}
/*
* 定义讲师类Teacher 继承 员工类Employee
*/
class Teacher extends Employee {
// 定义一个打印name的方法
public void printName() {
System.out.println("name=" + name);
}
}
/*
* 定义测试类
*/
public class ExtendDemo01 {
public static void main(String[] args) {
// 创建一个讲师类对象
Teacher t = new Teacher();
// 为该员工类的name属性进行赋值
t.name = "小明";
// 调用该员工的printName()方法
t.printName(); // name = 小明
// 调用Teacher类继承来的work()方法
t.work(); // 尽心尽力地工作
}
}2.3 继承后的特点——成员变量,就近原则,子类有就使用子类的,否则使用父类的//记忆
当类之间产生了关系后，其中各类中的成员变量，又产生了哪些影响呢？
成员变量不重名
如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：
class Fu {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num2 = 6;
// Zi中的成员方法
public void show() {
// 访问父类中的num，
System.out.println("Fu num="+num); // 继承而来，所以直接访问。
// 访问子类中的num2
System.out.println("Zi num2="+num2);
}
}
class ExtendDemo02 {
public static void main(String[] args) {
// 创建子类对象
Zi z = new Zi();
// 调用子类中的show方法
z.show();
}
}
演示结果：
Fu num = 5
Zi num2 = 6成员变量重名
如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：
class Fu {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
// 访问父类中的num
System.out.println("Fu num=" + num);//就近原则,子类有就使用子类的,否则使用父类的
// 访问子类中的num
System.out.println("Zi num=" + num);
}
}
class ExtendsDemo03 {
public static void main(String[] args) {
// 创建子类对象
Zi z = new Zi();
// 调用子类中的show方法
z.show();
}
}
演示结果：
Fu num = 6
Zi num = 6子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super 关键字，修饰父类成员变量，类似于之前学过的 this 。
使用格式：
super.父类成员变量名子类方法需要修改，代码如下：
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
//访问父类中的num
System.out.println("Fu num=" + super.num);
//访问子类中的num
System.out.println("Zi num=" + this.num);
}
}
演示结果：
Fu num = 5
Zi num = 6小贴士：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。
2.4 继承后的特点——成员方法,就近原则,子类有就使用子类的,否则使用父类的//记忆
当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？
成员方法不重名
如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：
class Fu{
public void show(){
System.out.println("Fu类中的show方法执行");
}
}
class Zi extends Fu{
public void show2(){
System.out.println("Zi类中的show2方法执行");
}
}
public class ExtendsDemo04{
public static void main(String[] args) {
Zi z = new Zi();
//子类中没有show方法，但是可以找到父类方法去执行
z.show();
z.show2();
}
}成员方法重名——重写(Override)//记忆
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。
-
方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写(能够继承拿到然后在子类重写一遍)//记忆
代码如下：
class Fu {
public void show() {
System.out.println("Fu show");
}
}
class Zi extends Fu {
//子类重写了父类的show方法
public void show() {
System.out.println("Zi show");
}
}
public class ExtendsDemo05{
public static void main(String[] args) {
Zi z = new Zi();
// 子类中有show方法，只执行重写后的show方法
z.show(); // Zi show
}
}重写的应用//记忆
子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。比如新的手机增加来电显示头像的功能，代码如下：
public class Test02 {
public static void main(String[] args) {
Zi z = new Zi();
z.method();//就近原则,子类有就使用子类的,否则使用父类的//zi
}
}
class Fu {
public static void method(){
System.out.println("传家宝");
// return;
}
}
class Zi extends Fu{//想使用父类的,又想有子类特有的,目的,为了让子类比父类更加强大,方法重写,应用场景
//能够继承拿到然后在子类重写一遍
public static void method(){
//想在子类里面使用父类里面的东西,super,超类的,父类的
//super.method();//表示调用使用父类里面的method方法
//想使用父类的静态的东西,父类名.
Fu.method();
System.out.println("学好Java月薪过万");
}
}
//class Fu {
// public void method(){
// System.out.println("传家宝");
// }
//}
//
//class Zi extends Fu{//想使用父类的,又想有子类特有的,目的,为了让子类比父类更加强大,方法重写,应用场景
// //能够继承拿到然后在子类重写一遍
// public void method(){
// //想在子类里面使用父类里面的东西,super,超类的,父类的
// super.method();//表示调用使用父类里面的method方法
//
//
// System.out.println("学好Java月薪过万");
// }
//}小贴士：这里重写时，用到super.父类成员方法，表示调用父类的成员方法。
注意事项//记忆
-
2.子类重写方法的访问权限要大于或者等于父类(子类要比父类更加强大,强大到访问权限都比父类强大,不能比父类弱)
-
子类方法覆盖父类方法，返回值类型(子父类关系,要求子类的返回值是父类返回值的子类)、函数名和参数列表都要一模一样。
提示:访问权限从小到大排序如下:private-默认修饰符-protected-public
private(私有仅仅在本类中被访问)-默认什么都不写(默认可以在同一个包下被访问,巧记默认同胞)
protected(受保护的,只能给子类去访问不管是否同包)-public(公有在哪里都可以访问,公有秒杀)
2.5 继承后的特点——构造方法//记忆
当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？
首先我们要回忆两个事情，构造方法的定义格式和作用。
-
构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
-
构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个
super()，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代码如下：
public class Test04 {
public static void main(String[] args) {
Erzi z = new Erzi();
System.out.println(z.i);//0,父类数据,子类创建对象的时候,才给它赋值
}
}
class Fuqin{
int i;//0
public Fuqin(){
// System.out.println("父类的构造方法");//做其他东西
i = 666;//给成员变量赋值
}
public Fuqin(int j){//j = 888;
i = j;
}
}
class Erzi extends Fuqin{
public Erzi(){
//子类的构造方法中默认有一个super() ，表示调用父类的构造方法,不写也是写,系统给你写
// super();//只要你写了,就按照你写的走
super(888);//super()无参没有,手动调用父类有参构造方法,是int 变量
// System.out.println(666);
}
}
//子类的构造方法默认会通过super()访问父类的构造方法目的是让了创建子类对象的时候给父类数据进行初始化比如给成员变量赋值或者做其他东西
2.6 super和this
父类空间优先于子类对象产生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。
super ：代表父类的存储空间标识(可以理解为父类的引用,实际是个内存块)
上面内存图对应的代码如下:
super和this的含义//记忆
-
super ：代表父类的存储空间标识(可以理解为父类的引用,实际是个内存块)
-
this ：代表当前对象的引用(谁调用就代表谁,存储的是地址值)
super和this的用法//记忆
-
访问成员
this.成员变量 -- 本类的或者父类的,看就近原则就可以了
super.成员变量 -- 父类的
this.成员方法名() -- 本类的或者父类的,看就近原则就可以了
super.成员方法名() -- 父类的用法演示，代码如下：
class Animal {
public void eat() {
System.out.println("animal : eat");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("cat : eat");
}
public void eatTest() {
this.eat(); // this 调用本类的方法
super.eat(); // super 调用父类的方法
}
}
public class ExtendsDemo08 {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Cat c = new Cat();
c.eatTest();
}
}
输出结果为：
animal : eat
cat : eat
animal : eat-
访问构造方法的注意事项://记忆选择题
this(...) -- 本类的构造方法
super(...) -- 父类的构造方法子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super(),
super()默认不写也是写,系统给你写,但是只要你写了(this()或者super()),按照你写来,系统不再提供
super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现(还不能有根本停不下来的情况)
2.7 继承后类与类之间的关系与特点//记忆,(能够说出继承的特点,或者说注意事项!),(java中的继承只支持单继承(即一个类只能有一个父类一个孩子只能有一个亲爹),但是可以多层继承(子继承父父继承爷就相当于孙子间接继承了爷爷)
-
Java只支持单继承，不支持多继承。//父类就是亲爹,只能有一个
//一个类只能有一个父类，不可以有多个父类,即继承是亲生关系,一个孩子只能有一个亲爹
class C extends A{} //ok
class C extends A，B{} //error,报错-
Java支持多层继承(继承体系)。
//相当于现实生活中的子父爷关系
class A{}
class A extends B{}
class B extends C{}
//A间接继承了C,可以使用C里面可以继承过来的东西,非私有成员变量和成员方法
2.8 抽象方法
由来:父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体{}，只有声明还有意义，而方法主体{}则没有存在的意义了。我们把没有方法主体{}的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
定义
-
抽象方法 ： 没有方法体的方法。
-
抽象类：包含抽象方法的类,但是更准备的说法应该是用abstract修饰的类就是抽象类,抽象类不一定有抽象方法//记忆
2.8.1 abstract使用格式,抽象的
抽象方法
使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
定义格式：
修饰符 abstract 返回值类型 方法名 (参数列表)；代码举例：
public abstract void run()；抽象类只有一个特点:抽象类不能创建对象,其他东西跟普通类一样!!!//重点
如果一个类包含抽象方法，那么该类必须是抽象类。
定义格式：
abstract class 类名字 { }代码举例：
public abstract class Animal { public abstract void run()；}抽象的使用//记忆
继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。
代码举例：
public class Test06 {
public static void main(String[] args) {
// Animal a = new Animal();//抽象类不能创建对象,抽象类,就是抽象的,不是具体的,没有具体的对象,不能创建对象
// Cat c = new Cat();//Cat抽象类不能创建对象
// c.eat();
//
// Sheep d = new Sheep();
// d.eat();
Cat c = new Cat();
c.eat();//就近原则
System.out.println(c.i);
c.show();
}
}
//包含抽象方法的类,但是更准备的说法应该是用abstract修饰的类就是抽象类,抽象类不一定有抽象方法
abstract class Animal {//有抽象方法的类,是抽象类,加上标记abstract关键字
//所有动物都吃鱼?不合理,所有都会吃饭的功能,但是具体怎么吃,我不知道,不太清楚,对于我来说就是抽象的,抽象方法
public abstract void eat();//{}抽象方法{}去掉加上标记abstract关键字,未实现的方法
// public abstract void eat2();//{}抽象方法{}去掉加上标记abstract关键字,未实现的方法
int i = 666;
public void show(){
System.out.println("show");
}
}
class Cat extends Animal {//想成为抽象类的子类,要么也是抽象类(没有意义),要么重写抽象类里面所有的抽象方法,alt enter
@Override
public void eat() {//重写抽象方法eat,增加{}方法体,里面做事情
System.out.println("吃鱼");
}
}
//
//class Sheep extends Animal {
//
//}此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。
2.8.2注意事项//记忆,选择题
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。
-
抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。//!!!
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体{}，做不了事情,没有意义。
-
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。//
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
-
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。//!!!
理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
-
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。// !!!
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
3.接口
3.1 概述,了解一下
概述:从广义上讲接口就是对外提供的规则(扩展功能),比如USB接口,从狭义上在Java里面指的是用interface修饰的东西
接口，是Java语言中另一种引用数据类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了常量和方法，其中方法包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。
接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类(例如接口不是类,凡是类都有构造方法,接口没有构造方法)，而是另外一种引用数据类型。
引用数据类型：数组，类，接口等,总之不是基本数据类型就是引用数据类型
接口的使用，几乎跟抽象类的用法一致:它也不能创建对象，但是可以被实现（implements ，类似于继承,理解继承是亲生的,实现是干的关系）。一个实现接口的类（可以看做是接口的干儿子类），需要实现接口中所有的抽象方法，创建该干儿子类(实现类)对象，就可以调用方法了，否则它必须是一个抽象类。
3.2 定义格式
public interface 接口名称 {//跟以前类的写法差不多一致,把class换成interface即可
// 抽象方法1.7之前,方法怎么写都是拿main方法过来修改,m,去掉static
// 默认方法1.8以后
// 静态方法1.8以后
// 私有方法1.9以后
}含有抽象方法,//跟抽象类里面的抽象方法用法一致,JDK1.7以前
抽象方法：使用abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。
代码如下：
public interface InterFaceName {
public abstract void method();//抽象方法存在的意义,让子类强制去重写从而实现的事情
//void method();//这种写法跟上面写法一样,public abstract不写也是写,系统给我写,接口独有的
}含有默认方法和静态方法//JDK1.8含以后
默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，供接口名点来直接调用,注意这里不可以给干儿子类调用!!!
代码如下：
public interface InterFaceName {
public default void method() {//default默认,以前类的普通方法加上default
// 执行语句
}
public static void method2() {//跟类的静态方法以前的写法是一样的,接口跟类有点不同,子类不能用
// 执行语句
}
}含有私有方法和私有静态方法//1.9为上面的默认方法和静态方法服务的
私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。
代码如下：
public interface InterFaceName {
private void method() {//私有方法,非静态
// 执行语句
}
private static void method2() {//私有方法,静态
// 执行语句
}
}3.3 基本的实现
实现的概述
类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。
非抽象子类实现接口：
-
必须重写接口中所有的抽象方法。
-
继承了接口的默认方法，可以直接调用，也可以重写。
实现格式：
class 类名 implements 接口名 {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
} 抽象方法的使用,基本的抽象方法会用就可以了,其他方法目前还是很少用的
必须全部实现，代码如下：
定义接口：
public interface LiveAble {//活着接口
// 定义抽象方法
public abstract void eat();
public abstract void sleep();
}定义实现类：
public class Animal implements LiveAble {
@Override //alt enter
public void eat() {
System.out.println("吃东西");
}
@Override
public void sleep() {
System.out.println("晚上睡");
}
}定义测试类：
public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
Animal a = new Animal();
// 调用实现后的方法
a.eat();
a.sleep();
}
}
输出结果：
吃东西
晚上睡默认方法的使用
可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。
-
继承默认方法，代码如下：
定义接口：
public interface LiveAble {
public default void fly(){
System.out.println("天上飞");
}
}定义实现类：
public class Animal implements LiveAble {
// 继承，什么都不用写，直接调用
}定义测试类：
public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
Animal a = new Animal();
// 调用默认方法
a.fly();
}
}
输出结果：
天上飞-
重写默认方法，代码如下：
定义接口：
public interface LiveAble {
public default void fly(){
System.out.println("天上飞");
}
}定义实现类：
public class Animal implements LiveAble {
@Override
public void fly() {
System.out.println("自由自在的飞");
}
}定义测试类：
public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
Animal a = new Animal();
// 调用重写方法
a.fly();
}
}
输出结果：
自由自在的飞静态方法的使用
静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：
定义接口：
public interface LiveAble {
public static void run(){//接口静态方法子类无法继承,更加无法重写
System.out.println("跑起来~~~");
}
}定义实现类：
public class Animal implements LiveAble {
// 无法重写静态方法
}定义测试类：
public class InterfaceDemo {
public static void main(String[] args) {
// Animal.run(); // 【错误】无法静态继承方法,不能这样调用,要通过下面的接口名.来调用
LiveAble.run(); //
}
}
输出结果：
跑起来~~~私有方法的使用
-
私有方法：只有默认方法可以调用。
-
私有静态方法：默认方法和静态方法都可以调用。
如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。同学们在已学技术的基础上，可以自行测试。
定义接口：
public interface LiveAble {
default void func(){
func1();
func2();
}
private void func1(){
System.out.println("跑起来~~~");
}
private void func2(){
System.out.println("跑起来33~~~");
}
}上面抽象方法1.7,默认方法和静态方法1.8,私有方法1.9总的使用代码如下:
public class Test02 {
public static void main(String[] args) {
//Jiekou j = new Jiekou();//接口不能创建对象,所有要有干儿子类,实现类
// Jiekou.method3();//接口静态方法,接口名.调用,子类不能使用
Son s = new Son();
s.method();
s.method2();
}
}
class Son implements Jiekou {//实现继承,干,亲生
//alt enter
@Override
public void method() {
System.out.println("sonmethod");
}
}
interface Jiekou {//default接口才有,类没有
//抽象方法,1.7和以前
// public void method(){};普通方法,修修改改
public abstract void method();//强制要求子类重写
//默认方法和静态方法,1.8
public default void method2(){//子类可以继承(实现),也可以重写,可选的,对象的,后有,后有的可以先有的
method4();
method4();
method5();
}
public static void method3(){//子类不能使用,不能继承也不能重写,子类不能使用,给接口服务,接口名.使用,类,
System.out.println("staticmethod3");
//method4();//报错
method5();
}
//私有方法,给上面默认方法和静态方法服务的,跟子类无关
private void method4(){//私有非静态
System.out.println("defaultmethod2");//100
}
private static void method5(){//私有静态,类,接口,类似,先有类,
System.out.println("staticdefaultmethod2");//100
}
}
3.4 接口的多实现,类与接口是实现关系,实现是干的关系,接口是干爹,干爹可以有多个,即类可以实现多个接口,认多个干爹而已
之前学过，在继承体系中，一个类只能继承(亲生血缘关系)一个父类(亲爹)。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。
实现格式：
class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【不重名时可选】
} [ ]： 表示可选操作。
抽象方法
接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：
定义多个接口：
interface A {
public abstract void showA();
public abstract void show();
}
interface B {
public abstract void showB();
public abstract void show();
}定义实现类：
public class C implements A,B{
@Override
public void showA() {
System.out.println("showA");
}
@Override
public void showB() {
System.out.println("showB");
}
@Override
public void show() {
System.out.println("show");
}
}默认方法
接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。代码如下：
定义多个接口：
interface A {
public default void methodA(){}
public default void method(){}
}
interface B {
public default void methodB(){}
public default void method(){}
}定义实现类：
public class C implements A,B{
@Override
public void method() {
System.out.println("method");
}
}静态方法
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。
优先级的问题
当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码如下：
定义接口：
interface A {
public default void methodA(){
System.out.println("AAAAAAAAAAAA");
}
}定义父类：
class D {
public void methodA(){
System.out.println("DDDDDDDDDDDD");
}
}定义子类：
class C extends D implements A {
// 未重写methodA方法
}定义测试类：
public class Test {
public static void main(String[] args) {
C c = new C();
c.methodA();
}
}
输出结果:
DDDDDDDDDDDD
3.5 接口的多继承【了解】,接口的出现打破了类单继承的局限性
一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。代码如下：
定义父接口:类与类是同类血缘关系继承,类与接口不是同类,没有血缘关系干实现,接口与接口是同类,血缘关系继承
interface A {
public default void method(){
System.out.println("AAAAAAAAAAAAAAAAAAA");
}
}
interface B {
public default void method(){
System.out.println("BBBBBBBBBBBBBBBBBBB");
}
}定义子接口：
interface D extends A,B{//alt enter,重写实现,快捷键
@Override
public default void method() {
System.out.println("DDDDDDDDDDDDDD");
}
}小贴士：
子接口重写默认方法时，default关键字可以保留。
子类重写默认方法时，default关键字不可以保留。(接口里面才有default方法,类里面没有)
3.6 其他成员特点//选择题可能考,考试前再记忆一下
-
接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰
-
接口中，没有构造方法,接口不是类,凡是类都有构造方法
-
接口中，没有静态代码块
4.多态
Fu f = new Zi();
f.method();//用非静态方法决定多态中的状态,zi,f看起来应该是父类状态,却走了子类状态,出现多种状态,简称多态
如何保证多态:(多种状态=向上转型+动态绑定,父类状态必须有,子类状态可有可无(子类可以继承父类状态))//重点
多态有啥好处,作用:(一个父亲可以代表多个儿子的状态(方法),多态,多种状态)//重点
4.1 概述
引入
多态是继封装、继承之后，面向对象的第三大特性。
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，多种状态
定义
-
多态： 是指同一行为，具有多个不同表现形式(状态)。//规律,规律,记住,应用,多态的效果
-
多态:同一种事物在不同时刻的不同状态,比如H20可以变成水,水蒸气,冰
前提【重点】
-
继承或者实现【二选一】
-
方法的重写【意义体现：不重写，无意义】
-
父类引用指向子类对象【格式体现】//引用:引用数据类型的变量就叫引用f,Fu f = new Zi();//()
4.2 多态的体现
多态体现的格式：
父类类型 变量名 = new 子类对象；
变量名.方法名();父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
代码如下：
Fu f = new Zi();//f引用 引用:引用数据类型的变量就叫引用 =指向 子类对象new Zi();引用存的地址值
f.method();//最终调用子类重写的method方法,要保证子类能够重写,所以父类一定有个同名的方法,编译时检查当使用多态方式调用非静态方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。//多态最要的规律:当满足Fu f = new Zi();时,用f去调用非静态方法,编译看左边(父类),运行的结果看右边(子类)(动态绑定),其他情况都看左边(父类)
总结1:实例 想要调用父类的方法或者成员变量 就需要创建父类的实例化
总结2:成员变量，静态方法看左边；动态方法：编译看左边，运行看右边
代码如下：
定义父类：
abstract class Animal {
public abstract void eat();
} 定义子类：
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}定义测试类：
public class Test {
public static void main(String[] args) {
// 多态形式，创建对象
Animal a1 = new Cat();
// 调用的是 Cat 的 eat
a1.eat();
// 多态形式，创建对象
Animal a2 = new Dog();
// 调用的是 Dog 的 eat
a2.eat();
}
}4.3 多态的好处
实际开发的过程中，父类类型作为方法的形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的复用性,扩展性,维护性。代码如下：
定义父类：
public abstract class Animal {
public abstract void eat();
} 定义子类：
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}定义测试类：
public class Test {
public static void main(String[] args) {
// 多态形式，创建对象
Animal c = new Cat();
Animal d = new Dog();
// 调用showCatEat
showCatEat(c);
// 调用showDogEat
showDogEat(d);
/*
以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
而执行效果一致
*/
showAnimalEat(c);
showAnimalEat(d);
}
public static void showCatEat (Cat c){
c.eat();
}
public static void showDogEat (Dog d){
d.eat();
}
public static void showAnimalEat (Animal a){
a.eat();
}
}由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。
所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的复用性,扩展性,维护性。
4.4 引用类型转换
多态的转型分为向上转型与向下转型两种：
向上转型
-
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。
使用格式：
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();//向上转型,多态,父类,子类同名方法向下转型,目的是为了,调用子类特有的变量和方法
-
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
使用格式：
子类类型 变量名 = (子类类型) 父类变量名;
Animal a = new Cat();//向上转换,把子类对象给父类,double d = 23;//int -double,大,上,父大,父类高高在上
如:Cat c =(Cat) a; //把父类引用强转为子类对象(引用) //int i = (int)d;为什么要转型//规律,编译看左边,运行看右边,其他都看左边
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类特有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
转型演示，代码如下：
定义类：
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void watchHouse() {
System.out.println("看家");
}
}定义测试类：
public class Test {
public static void main(String[] args) {
Animal a = new Cat();//向上转型
a.eat();//调用的是 Cat 的 eat
Cat c = (Cat)a;//向下转型
c.catchMouse();//调用的是 Cat 的 catchMouse } }转型的异常
转型的过程中，一不小心就会遇到这样的问题，请看如下代码：
public class Test {
public static void main(String[] args) {
Animal a = new Cat();// 向上转型
a.eat();// 调用的是 Cat 的 eat
Dog d = (Dog)a;// 向下转型
d.watchHouse();// 调用的是 Dog 的 watchHouse 【运行报错】 } }这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变量名 instanceof 引用数据类型(类,接口)
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。所以，转换前，我们最好先做一个判断，代码如下：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
if (a instanceof Cat){//instanceof实例对象,of所属关系,
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}
//instanceof实例对象,of所属关系,判断前面的对象是否属于后面类接口(类型),整体返回true,否则编译报错//
public class Test05 {
public static void main(String[] args) {
//instanceof实例对象,of所属关系,判断前面的对象是否属于后面类接口(类型),整体返回true,否则编译报错
Ren r = new Ren();
if (r instanceof Ren){
System.out.println("r是人类对象");
}
// if (r instanceof Ren2){//编译报错,判断前面的对象是否属于后面类接口(类型),整体返回true,否则编译报错
// System.out.println("r是人类对象");
// }
}
}
class Ren {
}
class Ren2 {
}
扫一扫
715
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
