黑马全套Java教程（五）

文章目录

• 18 抽象类
• • 18.1 概述
  • 18.2 抽象类的特点
  • 18.3 抽象类的成员特点
• 19 接口
• • 19.1 接口的特点
  • 19.2 接口的成员特点
  • 19.3 类和接口关系
  • 19.4 抽象类和接口的区别
• 20 形参和返回值
• • 20.1 类名作为形参和返回值
  • 20.2 抽象类名作为形参和返回值
  • 20.3 接口名作为形参和返回值
• 21 内部类
• • 21.1 概述
  • 21.2 成员内部类
  • 21.3 局部内部类
  • 21.4 匿名内部类
• 22 常用API
• • 22.1 Math类
  • 22.2 System类
  • 22.3 Object类
  • • 1. toString()方法
    • 2. equals()方法

黑马全套Java教程（一）
黑马全套Java教程（二）
黑马全套Java教程（三）
黑马全套Java教程（四）

本博客配套黑马教学视频，视频可看B站，作为代码记录博客，从d175个视频开始，视频链接

18 抽象类

18.1 概述

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

例：抽象类和抽象方法定义，需要用abstract关键字

public abstract class Animal {
//    public void eat(){
//        System.out.println("吃东西");
//    }public abstract void eat();   //抽象方法
}

18.2 抽象类的特点

• 抽象类和抽象方法必须使用abstract关键字修饰

public abstract class 类名{}
public abstract void eat();

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 抽象类不能实例化

抽象类如何实例化？
参照多态的方式，通过子类对象实例化，这叫抽象类多态

代码如下：
Animal.java

//抽象方法的类一定是抽象类；抽象类里面不一定要抽象方法
public abstract class Animal {   //抽象类public abstract void eat();  //抽象方法public void sleep(){System.out.println("睡觉");}
}

Cat.java

public class Cat extends Animal{   //继承抽象类@Overridepublic void eat() {           //重写抽象类里的抽象方法System.out.println("猫吃鱼");}
}

AnimalDemo.java

package myAbstract.Demo2;public class AnimalDemo {public static void main(String[] args) {Animal a = new Cat();a.eat();a.sleep();System.out.println("----------------");Cat b = new Cat();b.eat();b.sleep();}
}

18.3 抽象类的成员特点

• 成员变量：可以是变量，也可以是常量
• 构造器：有构造器，但不能实例化。
• 成员方法：可以有抽象方法，用于限定子类必须完成某些动作；也可以有非抽象方法，提高代码复用性

那么，构造器的作用是什么呢？：用于子类访问父类数据的初始化

Animal.java

//抽象类
public abstract class Animal {private int age = 20;private final String city = "北京";public Animal(){}public Animal(int age){this.age = age;}public void show(){age = 40;   //就近System.out.println(age);System.out.println(city);}public abstract void eat();
}

Cat.java

public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

AnimalDemo.java

//测试类
public class AnimalDemo {public static void main(String[] args) {Animal a = new Cat();a.eat();a.show();}
}

案例：猫和狗

Animal.java

package myAbstract.Demo4;
//抽象类
public 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();
}

Cat.java

package myAbstract.Demo4;public class Cat extends Animal{public Cat() {}public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

Dog.java

package myAbstract.Demo4;public class Dog extends Animal{public Dog() {}public Dog(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("狗吃骨头");}
}

AnimalDemo.java

package myAbstract.Demo4;
//测试类
public class AnimalDemo {public static void main(String[] args) {Animal a = new Cat();a.setName("加菲猫");a.setAge(5);System.out.println(a.getName() + "," + a.getAge());a.eat();System.out.println("-----------");a = new Cat("橘猫", 6);System.out.println(a.getName() + "," + a.getAge());a.eat();}
}

19 接口

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用
Java中的接口更多的体现在对行为的抽象

19.1 接口的特点

• 接口用关键字interface修饰，public interface 接口名{}
• 类实现接口用implements表示：public class 类名 implements 接口名{}
• 接口不能实例化

接口如何实现实例化？
参照多态的方式，通过实现类对象实例化，这叫接口多态

多态的形式：具体类多态，抽象类多态，接口多态
多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象

接口的实现类：要么重写接口中的所有抽象方法；要么是抽象类

代码：
Jumpping.java

package myInterface.Demo1;
//定义了一个接口
public interface Jumpping {       //换了关键字public abstract void jump();  //public abstract可省略
}

Cat.java

package myInterface.Demo1;public class Cat implements Jumpping{@Overridepublic void jump() {System.out.println("猫可以调高了");}
}

Dog.java

package myInterface.Demo1;public abstract class Dog implements Jumpping{
}

JumppingDemo.java

package myInterface.Demo1;public class JumppingDemo {public static void main(String[] args) {//Jumpping j = new Jumpping();   //报错Jumpping j = new Cat();j.jump();}
}

19.2 接口的成员特点

• 成员变量：只能是常量，默认修饰符public static final
• 构造方法：接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的
• 成员方法：只能是抽象方法，默认修饰符public abstract
  关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

Inter.java接口

package myInterface.Demo2;public interface Inter {public int num = 10;public final int num2 = 20;public static final int num3 = 30;   //static和final可以不写的，默认有int num4 = 40;//接口没有构造方法//public void show(){}public abstract void method();void show();
}

InterImpl.java

package myInterface.Demo2;//public class InterImpl implements Inter{
public class InterImpl extends Object implements Inter{  //extends Object默认有public InterImpl(){super();}@Overridepublic void method() {System.out.println("method");}@Overridepublic void show() {System.out.println("show");}
}

InterfaceDemo.java

package myInterface.Demo2;
//测试类
public class InterfaceDemo {public static void main(String[] args) {Inter i = new InterImpl();//接口中成员变量 默认被final修饰，且被static修饰//i.num = 20;  //报错System.out.println(i.num);System.out.println(Inter.num);System.out.println(i.num2);}
}

案例：猫和狗

Jumpping.java接口

package myInterface.Demo3;public interface Jumpping {void jump();
}

Animal.java抽象方法

package myInterface.Demo3;public 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();
}

Cat.java

package myInterface.Demo3;public class Cat extends Animal implements Jumpping{public Cat(){}public Cat(String name, int age){super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void jump() {System.out.println("猫可以跳高了");}
}

Dog.java

package myInterface.Demo3;public class Dog {
}

AnimalDemo.java测试类

package myInterface.Demo3;//测试类
public class AnimalDemo {public static void main(String[] args) {//创建对象Jumpping j = new Cat();j.jump();//j.eat();   //报错System.out.println("--------------");Animal a = new Cat("加菲猫", 5);System.out.println(a.getName() + "," + a.getAge());a.eat();//a.jump();   //报错System.out.println("----------------");Cat c = new Cat("橘猫", 6);c.eat();c.jump();}
}

19.3 类和接口关系

• 类和类关系：继承关系，只能是单继承，但是可以多层继承
• 类和接口关系：实现关系，但是单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
• 接口和接口关系：继承关系，可以单继承，也可以多继承

Inter1.java接口1

package myInterface.Demo4;public interface Inter1{
}

Inter2.java接口2

package myInterface.Demo4;public interface Inter2 {
}

Inter3.java接口3

package myInterface.Demo4;public interface Inter3 extends Inter1, Inter2 {
}

InterImpl.java

package myInterface.Demo4;public class InterImpl extends Object implements Inter1, Inter2, Inter3 {
}

19.4 抽象类和接口的区别

举例说明：

案例：运动员和教练

代码实现如下：
SpeakEnglish接口

package myInterface.Demo5;//说英语的接口
public interface SpeakEnglish {public abstract void speak();
}

Person抽象类

package myInterface.Demo5;public abstract class Person {private String name;private int age;public Person(){}public Person(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();
}

Coach抽象类继承Person抽象类

package myInterface.Demo5;
//抽象教练类
public abstract class Coach extends Person{public Coach() {}public Coach(String name, int age) {super(name, age);}public abstract void teach();
}

Player抽象类继承Person抽象类

package myInterface.Demo5;public abstract class Player extends Person{public Player() {}public Player(String name, int age) {super(name, age);}public abstract void study();
}

BasketballCoach.java

package myInterface.Demo5;public class BasketballCoach extends Coach{public BasketballCoach() {}public BasketballCoach(String name, int age) {super(name, age);}@Overridepublic void teach() {System.out.println("篮球教练教投篮");}@Overridepublic void eat() {System.out.println("篮球教练吃羊肉");}
}

BasketballPlayer.java

package myInterface.Demo5;public class BasketballPlayer extends Player{public BasketballPlayer() {}public BasketballPlayer(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("篮球运动员吃牛肉");}@Overridepublic void study() {System.out.println("篮球运动员学习投篮");}
}

PingPangCoach.java

package myInterface.Demo5;public class PingPangCoach extends Coach implements SpeakEnglish{public PingPangCoach() {}public PingPangCoach(String name, int age) {super(name, age);}@Overridepublic void teach() {System.out.println("乒乓球教练教发球");}@Overridepublic void eat() {System.out.println("乒乓球教练吃小白菜");}@Overridepublic void speak() {System.out.println("乒乓球教练说英语");}
}

PingPangPlayer.java

package myInterface.Demo5;public class PingPangPlayer extends Player implements SpeakEnglish{public PingPangPlayer() {}public PingPangPlayer(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("乒乓球运动员喝小米粥");}@Overridepublic void study() {System.out.println("乒乓球运动员学习打乒乓球");}@Overridepublic void speak() {System.out.println("乒乓球运动员说英语");}
}

20 形参和返回值

20.1 类名作为形参和返回值

• 方法的形参是类名，其实需要的是该类的对象
• 方法的返回值是类名，其实返回的是该类的对象

代码实现：
Cat.java

package myArgs.Demo1;public class Cat {public void eat() {System.out.println("猫吃鱼");}
}

CatOperator.java

package myArgs.Demo1;public class CatOperator {public void useCat(Cat c){c.eat();}public Cat getCat(){Cat c = new Cat();return c;}
}

CatDemo.java

package myArgs.Demo1;
//测试类
public class CatDemo {public static void main(String[] args) {//创建操作类对象，并调用方法CatOperator co = new CatOperator();Cat c = new Cat();co.useCat(c);Cat c2 = co.getCat();c2.eat();}
}

20.2 抽象类名作为形参和返回值

• 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
• 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

代码如下：
Animal.java

package myArgs.Demo2;public abstract class Animal {public abstract void eat();
}

AnimalOperator.java

package myArgs.Demo2;public class AnimalOperator {public void useAnimal(Animal a){a.eat();}public Animal getAnimal(){Animal a = new Cat();return a;}
}

Cat.java

package myArgs.Demo2;public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

AnimalDemo.java

package myArgs.Demo2;public class AnimalDemo {public static void main(String[] args) {//创建对象，调用方法AnimalOperator ao = new AnimalOperator();Cat a = new Cat();ao.useAnimal(a);Animal a2 = ao.getAnimal();a2.eat();}
}

20.3 接口名作为形参和返回值

• 方法的形参是接口名，其实需要的是该接口的实现类对象
• 方法的返回值是接口名，其实返回的是该接口的实现类对象

Jumpping.java

package myArgs.Demo3;public interface Jumpping {void jump();
}

Cat.java

package myArgs.Demo3;public class Cat implements Jumpping{@Overridepublic void jump() {System.out.println("猫可以跳高了");}
}

JumppingOperator.java

package myArgs.Demo3;public class JumppingOperator {public void useJumpping(Jumpping j){j.jump();}public Jumpping getJumpping(){Jumpping j = new Cat();return j;}
}

JumppingDemo.java

package myArgs.Demo3;
//测试类
public class JumppingDemo {public static void main(String[] args) {//创建操作类对象，并调用方法JumppingOperator jo = new JumppingOperator();Jumpping j = new Cat();jo.useJumpping(j);Jumpping j2 = jo.getJumpping();jo.useJumpping(j2);}
}

21 内部类

21.1 概述

内部类：就是在一个类中定义一个类。
举例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类访问特点：

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，必须创建对象

按照内部类在类中定义的位置不同，可以分为如下两种形式：

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类
  

代码：

package myInnerClass.Demo1;
/*内部类格式：public class 类名{修饰符 class 类名{}}内部类的特点：内部类可以直接访问外部类的成员，包括私有外部类要访问内部类的成员，必须创建对象*/
public class Outer {private int num = 10;public class Inner{public void show(){System.out.println(num);}}public void method(){//show();   //报错Inner i = new Inner();i.show();}
}

21.2 成员内部类

成员内部类，外界如何创建对象使用呢？

• 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
• 范例：Outer.Inner oi = new Outer().new Inner();

代码一：
Outer.java

package myInnerClass.Demo2;public class Outer {private int num = 20;public class Inner{public void show(){System.out.println(num);}}
}

InnerDemo.java

package myInnerClass.Demo2;
//测试类
public class InnerDemo {public static void main(String[] args) {//创建内部类对象并调用方法Outer.Inner oi = new Outer().new Inner();oi.show();}
}

代码二：
Outer.java

package myInnerClass.Demo2;public class Outer {private int num = 20;private class Inner{public void show(){System.out.println(num);}}public void method(){Inner i = new Inner();i.show();}
}

InnerDemo.java

package myInnerClass.Demo2;
//测试类
public class InnerDemo {public static void main(String[] args) {//创建内部类对象并调用方法Outer o = new Outer();o.method();}
}

21.3 局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问内部类的成员，也可以访问方法内的局部变量

Outer.java

package myInnerClass.Demo3;public class Outer {private int num = 10;public void method() {int num2 = 20;class Inner {public void show() {System.out.println(num);System.out.println(num2);}}Inner i = new Inner();i.show();}
}

OuterDemo.java

package myInnerClass.Demo3;
//测试类
public class OuterDemo {public static void main(String[] args) {Outer o = new Outer();o.method();}
}

21.4 匿名内部类

局部内部类的一种特殊形式
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

interface接口

package myInnerClass.Demo4;public interface Inter {void show();
}

Outer.java

package myInnerClass.Demo4;
/*前提：存在一个类或者接口这里的类可以是具体类也可以是抽象类格式：new 类名或者接口名(){重写方法;};本质是什么呢？是一个继承了该类或者实现了该接口的子类匿名对象*/
public class Outer {public void method(){//多次调用Inter i = new Inter(){@Overridepublic void show() {System.out.println("匿名内部类");}};i.show();i.show();}
}

OuterDemo.java

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

匿名内部类在开发中的使用

Jumpping接口

package myInnerClass.Demo5;
/*跳高接口*/
public interface Jumpping {void jump();
}

Cat.java

package myInnerClass.Demo5;public class Cat implements Jumpping{@Overridepublic void jump() {System.out.println("猫可以跳高了");}
}

Dog.java

package myInnerClass.Demo5;public class Dog implements Jumpping{@Overridepublic void jump() {System.out.println("狗可以跳高了");}
}

JumppingOperator.java

package myInnerClass.Demo5;//接口操作类，里面有一个发方法，方法的参数是接口名
public class JumppingOperator {public void method(Jumpping j ){j.jump();}
}

JumppingDemo.java

package myInnerClass.Demo5;public class JumppingDemo {public static void main(String[] args) {JumppingOperator jo = new JumppingOperator();Jumpping j = new Cat();jo.method(j);Jumpping j2 = new Dog();jo.method(j2);System.out.println("----------");jo.method(new Jumpping() {@Overridepublic void jump() {System.out.println("猫可以跳高了");}});jo.method(new Jumpping() {@Overridepublic void jump() {System.out.println("狗可以跳高了");}});}
}

22 常用API

22.1 Math类

常用方法如下：

package myMath.Demo1;/*Math类的常用方法*/
public class MathDemo {public static void main(String[] args) {//abs：返回绝对值, int aSystem.out.println("int");System.out.println(Math.abs(88));System.out.println(Math.abs(-88));System.out.println("----------------");//ceil：返回大于或等于参数的最小double值，为整数， double aSystem.out.println("ceil");System.out.println(Math.ceil(12.34));System.out.println(Math.ceil(12.56));System.out.println("-----------------");//floor：返回小于或等于参数的最大double值，为整数， double aSystem.out.println("floor");System.out.println(Math.floor(12.34));System.out.println(Math.floor(12.56));System.out.println("-----------------");//round：按照四舍五入返回最接近参数的intSystem.out.println("round");System.out.println(Math.round(12.34F));System.out.println(Math.round(12.56F));System.out.println("-----------------");//max(int a, int b)：返回两者最大值System.out.println("max");System.out.println(Math.max(66, 88));System.out.println("-----------------");//minSystem.out.println("min");System.out.println(Math.min(66, 88));System.out.println("-----------------");//public static double pow(double a, double b)：返回a的b次幂System.out.println("pow");System.out.println(Math.pow(2.0, 3.0));System.out.println("-----------------");//public static double random()：返回值为double的正值，范围[0.0, 1.0)System.out.println("random");System.out.println(Math.random());System.out.println(Math.random() * 100);System.out.println((int) (Math.random() * 100));System.out.println((int) (Math.random() * 100) + 1);}
}

22.2 System类

System包含几个有用的类字段和方法，它不能被实例化

常用方法：

方法一：exit()

package mySystem.Demo1;
/*System类的常用方法*/
public class SystemDemo {public static void main(String[] args) {System.out.println("开始");//public static void exit(int status)：终止当前运行的JAVA虚拟机，非零表示异常终止System.exit(0);System.out.println("结束");}
}

方法二：currentTimeMillis()

package mySystem.Demo1;public class SystemDemo1 {public static void main(String[] args) {//public static long currentTimeMillis():返回当前时间（以毫秒为单位）System.out.println(System.currentTimeMillis());  //毫秒值：当前时间与1970年之间的System.out.println(System.currentTimeMillis()*1.0/1000/60/60/24/365+"年");long start = System.currentTimeMillis();for(int i =0;i<10000;i++){System.out.println(i);}long end = System.currentTimeMillis();System.out.println("共耗时："+ (end-start)+"毫秒");}
}

22.3 Object类

Object是类层次结构的跟，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类
构造方法：public Object()

回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？
因为它们的顶级父类只有无参构造方法

1. toString()方法

代码：
Student.java

package myObject;public 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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}

ObjectDemo.java

package myObject;//Object是类层次结构的跟，每个类都可以将Object作为超类，所有类都直接或者间接的继承该类//看源码的方法：选中，按下Ctrl+B
public class ObjectDemo {public static void main(String[] args) {Student s = new Student("林青霞",30);System.out.println(s);   //myObject.Student@49e4cb85System.out.println(s.toString());}
}

2. equals()方法

Student.java

package myObject.Demo2;public 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;}@Overridepublic boolean equals(Object o) {if (this == o) return true;   //比较地址是否相同//判断参数是否为null 或者 判断两个对象是否来自同一个类if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;   //向下转型if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;}
}

ObjectDemo.java

package myObject.Demo2;
/*测试类public boolean equals(Object obj):指示一些其他对象是否等于此*/public class ObjectDemo {public static void main(String[] args) {Student s1 = new Student("林青霞",30);Student s2 = new Student("林青霞",30);System.out.println(s1==s2);   //比较地址值System.out.println(s1.equals(s2));}
}

本博客到视频197截止！

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！