抽象类

1.抽象类

概述：

​ 用来描述抽象概念的类，叫做抽象类。抽象类中的方法不一定有具体的实现。

package org.wdit;

/**
 * 抽象类
 */
public class unit08 {
    public static void main(String[] args) {
        Pets pets = new Dod();
        pets.voice();
        pets.eat();
        Pets pets1 = new Cat();
        pets1.voice();
        pets1.eat();
    }
}
abstract class Pets{

    public abstract void voice();

    //吃东西
    public abstract void eat();
}
//如果父类中有抽象方法，则·子类必须实现父类的抽象方法
class Dod extends Pets{

    @Override
    public void voice() {
        System.out.println("汪汪叫");

    }

    @Override
    public void eat() {
        System.out.println("狗吃肉");

    }
}
class Cat extends Pets{

    @Override
    public void voice() {
        System.out.println("喵喵叫");
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");

    }
}

特点：

​ 1.不能直接被创建对象，只能通过子类去创建。

​ 2.抽象类中不一定有抽象方法的类，有抽象方法的类一定是抽象类。

​ 3.被abstract关键字修饰

​ 4.抽象类可以被继承

​ 普通类：其子类必须重写抽象类中的抽象方法

​ 抽象类子类：可以不用重写抽象方法

成员特点：

​ 抽象类成员特点：

​ 成员变量： 可以是变量，也可以是final修饰的变量（常量），静态变量

​ 成员方法 ： 可以是抽象方法，也可以是非抽象方法

​ 构造方法 ： 有构造方法，但是不能被创建对象；其作用是子类访问父类构造方法，对其数据进行初始化时使用

package org.wdit.unit09;

/**
 * 抽象类成员特点
 *      成员变量
 *          可以是变量，也可以是final修饰的变量（常量），静态变量
 *      成员方法
 *          可以是静态方法，也可以是非静态方法
 *      构造方法
 *          有构造方法，但是不能被创建对象；其作用是子类访问父类构造方法，对其数据进行初始化时使用
 */
public class AbstractDemo {
}
abstract class Animal{
    public int age;
    private String name;
    public final int num=20;

    //普通方法
    public void method(){

    }
    //抽象方法
    public abstract void method2();
    //静态方法
    public static void method3(){}
    //
    public final void method4(){}

    //构造方法
    public Animal(){}

}

注意事项：

​ 1.有构造方法，但不能被实例化。用于子类初始化父类数据

​ 2.一个类，如果没有抽象方法，但是被定义成抽象类，其目的是为了不让创建该类对象。

​ 3.abstract与其它关键字的关系：

​ 1.private：冲突关系，因为抽象方法必须被子类重写，而private修饰的方法，不能被继承，从而导致不能被重写。

​ 2.final：冲突，因为被final关键字修饰的方法，不能被重写

​ 3.static：冲突，因为static修饰的方法是随类的加载而加载，可以直接通过类名被调用，没有意义

package org.wdit.unit09;

import java.security.DigestException;

/**
 * 需求：
 *     动物：猫，狗
 *     共有的属性和行为：名字，年龄，吃饭，睡觉
 */
public class AbstractText {
    public static void main(String[] args) {
        Dog dog = new Dog("老黑",3);

        dog.show();
        dog.voice();
        dog.eat();
        dog.sleep();

        Cat cat = new Cat("pig",3);

        cat.show();
        cat.voice();
        cat.eat();
        cat.sleep();
    }
}
abstract class Animal1{
    private String name;
    private int age;
    public abstract void voice();
    public abstract void eat();
    public Animal1(){

    }
    public Animal1(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void show(){
        System.out.println("名字:"+name+"年龄:"+age);
    }
}
class Dog extends Animal1{
    public Dog(String name,int age){
        super(name, age);
    }


    @Override
    public void voice() {
        System.out.println("汪汪叫");
    }

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}
class Cat extends Animal1{
    public Cat(String name,int age){
        super(name, age);
    }

    public Cat(){}
    @Override
    public void voice() {
        System.out.println("喵喵叫");
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

2.接口

概述：

​ 接口是一系列方法声明（方法规范）的集合。一个接口中只有方法的特征，没有方法的实现。因为这些方法可以在不同的类中做不同的实现，而这些实现可以具有不同的结果。

特点：

​ 1.定义关键字：interface

​ 格式： interface 接口{}

​ 2.实现接口关键字：implements

​ 格式：class 类名 implements 接口名{}

​ 3.接口不能被创建对象，但是它可以通过多态去实例化

​ 格式：接口名 变量名 = new 实现类名（）

​ 4.接口的实现类：

​ a.标准类：重写接口中的抽象方法

​ b.抽象类：不必重写接口中的抽象方法。交由子类来实现

public class InterfaceDemo {
}
class BiJiComputer implements ComputerExtend{
    @Override
    public void print() {
        System.out.println("打印");
    }

    public void learn(){
        System.out.println("我在学习");
    }
    public void playGame(){
        System.out.println("玩英雄联盟，爽歪歪" );
    }
}
abstract class TaiShiComputer implements ComputerExtend{
    
}
interface ComputerExtend{
    public abstract void print();
}

成员特点：

接口的成员特点：     
	1.成员变量         
		接口中不能有变量，只能是常量（默认被 public static final修饰）    	 
	2.成员方法         
		只能是抽象方法，并且默认被public abstract修饰     
	3.构造方法         
		没有构造方法

package zhaotongit.unit01;

/**
 * 接口的成员特点：
 *      1.成员变量
 *          接口中不能有变量，只能是常量（默认被public static final修饰）
 *      2.成员方法
 *          只能是抽象方法，并且默认被public abstract修饰
 *      3.构造方法
 *          没有构造方法
 */
public class InterfaceDemo {
    public static void main(String[] args) {
        //通过多态的方式去创建对象
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        System.out.println(myInterface.num);
        System.out.println(myInterface.num2);
        System.out.println(myInterface.num3);
        System.out.println(myInterface.num4);
        //直接通过接口名去调用
        System.out.println(MyInterface.num);
        System.out.println(MyInterface.num2);
        System.out.println(MyInterface.num3);
        System.out.println(MyInterface.num4);


    }
}
interface MyInterface{
    //1.成员变量,默认被 public static final修饰
    public int num = 10;
    //private int num1=10;
    public final int num2=10;
    public static int num3=30;
    public static final int num4 =40;
    
    //构造方法
    //public MyInterface(){};没有构造方法

    //2.成员方法
    public abstract void method();
    //abstract void method2();
    //public void method1();
}
interface MyInterface1{

}

class MyInterfaceImpl extends Object implements MyInterface,MyInterface1{
    public MyInterfaceImpl(){
        super();
    }

    @Override
    public void method() {
        System.out.println("你好");
    }

类与接口的关系：

​ 1.类与类

​ 继承关系：单继承或多层继承

​ 2.类与接口

​ 实现关系：单实现或多实现

​ 3.接口与接口

​ 继承关系：单继承或多继承

package zhaotongit.unit01;

/**
 * 1.类与类
 *
 * 		继承关系：单继承或多层继承
 *
 * 2.类与接口
 *
 *		实现关系：单实现或多实现
 *
 * 3.接口与接口
 *
 * 		继承关系：单继承或多继承
 */
public class InterfaceDemo1 {
}
class Father{}
class Mother{}
class Son extends Father{}
class Son1 extends Mother{}
//class Son2 extends Father,Mother{}
// 类与类：单继承或多层继承
interface Play{}
interface Sing{}
class Phone implements Play{}
class Computer implements Play,Sing{}
//类与接口：单实现或多实现
//interface Bother implements Play{}
interface Sister extends Play{}
interface Boy extends Play,Sing{}
//接口与接口：单继承或多继承

注意：

​ 面试题：java中的继承都是单继承？java中的类都是单继承？

接口和抽象类的区别：

1.组成区别

​ 抽象类;

​ 成员变量：变量与变量

​ 成员方法：可以是抽象方法，也可以是普通方法

​ 构造方法：有构造，但是不能创建对象

​ 接口：

​ 成员变量：常量

​ 成员方法：抽象方法 public abstract

​ 构造方法：没有构造方法

2.关系的区别

​ 类与抽象类：继承–单继承或多层继承

​ 类与接口：实现

​ 抽象类与接口：实现

​ 接口与接口：继承–单继承或多继承

3.引用的区别：

​ 抽象类：定义继承体系中相同属性和方法

​ 接口：类的扩展功能

形式参数是引用类型

​ 1.类：在T调用方法是，传入相应类的对象（匿名对象）

package zhaotongit.unit01;

/**
 * 形式参数是应用数据类型问题
 *      1.类
 */
public class FunctionDemo3 {
    public static void main(String[] args) {
        TeacherDemo teacherDemo=new TeacherDemo();
        //第一种：创建对象，传入对象
        Teacher teacher = new Teacher();
        teacherDemo.method(teacher);
        //第二种：传入匿名对象
        teacherDemo.method(new Teacher());
    }

}
class Teacher{
    public void teach(){
        System.out.println("教书");
    }
}
class TeacherDemo{
    public void method(Teacher teacher){
        teacher.teach();
    }
}

​ 2.抽象类：在方法调用时，传入抽象类的子类对象

​ 3.接口：在方法调用时，传入的是接口的实现类对象

返回值是引用类型

​ 1.类：返回相应类的对象（匿名对象）

package zhaotongit.unit01;

/**
 * 返回值是引用数据类型问题
 *      1.类
 *      2.抽象类
 *      3.接口
 */
public class FunctionDemo {
    //返回值类型是类
    public static Student method(){
        Student student = new Student("屈波",20);
        return student;
    }

    public static void main(String[] args) {
        Student sc =method();
        System.out.println(sc);
        sc.show();
    }
}
class Student{
    //成员变量
    private String name;
    private int age;
    //构造方法
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    //成员方法
    public void show(){
    System.out.println(name+"\n"+age);
}
}

​ 2.抽象类：返回抽象类的子类对象

package zhaotongit.unit01;

/**
 * 形式参数是引用类型--抽象类
 */
public class FunctionDemo1 {
    public static void main(String[] args) {
        //多态
        Pets pets = new Dog();
        Pets pets1 = new Cat();

        method(pets);
        method(pets1);
        
        Pets pets2 = method1();
        System.out.println(pets2);

    }
    //形式参数是引用类型--抽象类
    public static void method(Pets pets){
        pets.voice();
    }
    //返回值类型是抽象类
    public static Pets method1(){
        Pets pets = new Dog();
        //Dog dog =new Dog();
        System.out.println(pets);
        return pets;
    }

}
abstract class Pets{
    abstract void voice();
}
class Dog extends Pets{
    @Override
    void voice() {
        System.out.println("汪汪");
    }
}
class Cat extends Pets{

    @Override
    void voice() {
        System.out.println("喵喵喵");
    }
}

​ 3.接口：返回接口的实现类对象

package zhaotongit.unit01;

/**
 * 形式参数是引用数据类型---接口
 */
public class FunctionDemo2 {
    public static void main(String[] args) {
        //接口
        MyInterface2 myInterface2=new Demo();
        function(myInterface2);

       System.out.println(method());
    }
    //形式参数是引用数据类型---接口
    public static void function(MyInterface2 myInterface2){
        myInterface2.method();
    }
    //返回值类型是接口
    public static MyInterface2 method(){
        MyInterface2 myInterface2=new Demo();
        return myInterface2;
    }
}
interface MyInterface2{
    public abstract void method();

}
class Demo implements MyInterface2{

    @Override
    public void method() {
        System.out.println("你好");
    }
}

3.包

概述：

​ 其实就是文件夹

作用:

​ 对类进行分类管理

关键字：package

格式：

package 包名；（多级包用“.”隔开）

注意事项：

​ 1.package语句必须是第一条可执行语句

​ 2.一个java文件中，只能有一条package语句

​ 3.没有package语句，默认就是没有包

导包：

格式：import 包名.类名

import 包名.*

4.权限修饰符

权限修饰符	本类	同包	不同包下的子类	不同包的其他类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

1.常见修饰符

​ 1.权限修饰符：private，默认，protected，public

​ 2.状态修饰符：static ，final

​ 3.抽象修饰符：abstract

常用情景：

1.类

​ 权限修饰符，抽象修饰符，状态修饰符：final

​ 常用：public

2.成员变量

​ 权限修饰符，状态修饰符

​ 常用：private

​ 组合：public final

3.成员方法

​ 权限修饰符，状态修饰符，抽象修饰符

​ 常用：public

​ 组合：public static

​ public static final

​ public abstract

​ public final

4.构造方法

​ 权限修饰符