Java基础学习（8）

一、面向对象进阶版

1.1 抽象类和抽象方法

抽象方法:

将共性的行为 (方法) 抽取到父类之后由于每一个子类执行的内容是不一样所以，在父类中不能确定具体的方法体该方法就可以定义为抽象方法

抽象类:

如果一个类中存在抽象方法，那么该类就必须声明为抽象类

抽象方法定义：
public abstract 返回值类型 方法名(参数列表);

抽象类方法定义：
public abstract class 类名{}

抽象类和抽象方法的注意事项

1. 抽象类不能创建对象（实列化）
2. 抽象类不一定有抽象对象，有抽象方法的类一定是抽象类
3. 可以构造方法
4. 抽象类的子类
   要么重写抽象类中的所有抽象方法
要么是抽象类

测试类

package 抽象类和抽象方法;

public class Test {
    public static void main(String[] args) {
        sheep yang = new sheep("小样",16);
        yang.Action();
        System.out.println(yang.getName()+" "+yang.getAge());
    }
}

抽象方法和抽象类：

package 抽象类和抽象方法;

public abstract class Animal {
    private String name;
    private int 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 Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Animal() {
    }
    public void drink(){
        System.out.println("动物在喝水");
    }
    public abstract void Action();
}

package 抽象类和抽象方法;

public class sheep extends Animal{
    public sheep(String name, int age) {
        super(name, age);
    }

    public sheep() {
    }

    @Override
    public void Action() {
        System.out.println("山羊吃草");
    }
}

1.2 抽象类和抽象对象的意义

强制子类必须按照这种格式进行重写

1.3 接口

接口: 就是一种规则
出现接口段原因：

当出现子类一小部分的子类出现了共性，为了使得书写代码的统一性，就插入一个接口去定义这个部分共有的属性

接口的运用：

接口定义和使用

• 接口用关键字interface来定义

public interface 接口名{}

• 接口不能实例化
• 接口和类之间是实现关系，通过implements关键字表示

public class 类名 implements 接口名{}

• 接口的子类(实现类)
  1 .要么重写接口中的所有抽象方法 2 .要么是抽象类

接口的注意事项

1. 接口和类的实现关系，可以单实现，也可以多实现

public class类名 implements 接口名1，接口名2{}

2. 实现类还可以在继承一个类的同时实现多个接口

public class 类名 extends 父类implements 接口名1，接口名2{}

创建对象

package 接口练习;

public class Test {
    public static void main(String[] args) {
        //创建一个对象就行测试
        frog f = new frog("小娃",178);
        f.eat();
        f.swim();
        System.out.println(f.getAge()+", "+f.getName());
    }
}

接口

package 接口练习;

public interface Swim {
        public abstract void swim();
}

父类：

package 接口练习;

public abstract class Animal {
    private String name;
    private  int 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 Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Animal() {
    }
    public abstract void eat();
}

1.4 接口中的成员

• 成员变量
  只能是常量
  默认修饰符:public static final构造方法
• 成员方法
  没有
  只能是抽象方法默认修饰符:public abstract
• JDK7以前: 接口中只能定义抽象方法
• JDK8的新特性:接口中可以定义有方法体的方法
• JDK9的新特性:接口中可以定义私有方法

1.5 接口和类的来联系

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

1.6 关于接口多学三招

JDK8以后接口中新增的方法

JDK7以前: 接口中只能定义抽象方法
JDK8的新特性: 接口中可以定义有方法体的方法。 (默、静态)
JDK9的新特性: 接口中可以定义私有方法

• 允许在接口中定义默认方法，需要使用关键字 default 修饰
  作用: 解决接口升级的问题
• 接口中默认方法的定义格式
  格式: public default 返回值类型 方法名(参数列表) {}
  范例: public default void show() {}

接口中默认方法的注意事项

• 默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
• public可以省略，default不能省略
• 实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

JDK8以后接口中的静态方法

允许在接口中定义定义静态方法，需要用static修饰

接口中静态方法的定义格式
格式:public static 返回值类型 方法名(参数列表) {}
范例: public static void show(){}

接口中静态方法的注意事项

• 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
• public可以省略，static不能省略

JDK9新增方法

• 接口中私有方法的定义格式

格式1:private 返回值类型 方法名(参数列表)
范例1: private void show(){}
格式2:private static 返回值类型 方法名(参数列表) {}
范例2: private static void method(){ }

1.7 接口的运用

1. 接口代表规则，是行为的抽象。想要让哪个类拥有一个行为，就让这个类实现对应的接口就可以了。
2. 当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方式称之为接口多态

1.8 适配器的设计模式

• 设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

简单理解: 设计模式就是各种套路

• 适配器设计模式:解决接口与接口实现类之间的矛盾问题

1.9 内部类

写在一个类里面的类就叫做内部类

• 内部类表示的事物是外部类的一部分
• 内部类单独出现没有任何意义

内部类的访问特点

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

1.9.1 成员内部类

• 写在成员位置的，属于外部类的成员
• 成员内部类可以被一些修饰符所修饰，比如: private，默认，protected，public，static等
• 在成员内部类里面，JDK16之前不能定义静态变量，JDK 16开始才可以定义静态变量。
  

获取成员内部类对象：

1.在外部类中编写方法，对外提供内部类的对象
2. 直接创建格式:外部类名.内部类名 对象名=外部类对象内部类对象;

public class Outer{
	private int a = 10;
	class Inter{
		private int a = 20;
		public void show(){
			int a = 30;
			 System.out.println(a);//30
			 System.out.println(this.a);//20
			 System.out.println(Outer.this.a);//10
		}
	} 
}

内部类的内存图

1.9.2 静态内部类

静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建外部类的对象

非静态方法: 先创建对象，用对象调用
静态方法: 外部类名.内部类名方法名()

//先创建对象
Outer.inner oi = new Outer.inner();
//用对象调用
oi.show2();

Outer.inner.show2();

1.9.3 局部内部类

1. 将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。
2. 外界是无法直接使用，需要在方法内部创建对象并使用。
3. 该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

package 局部内部类;

public class Test {
    public static void main(String[] args) {
        Outer o =new Outer();
        o.show();
    }
}

package 局部内部类;

public class Outer {
    int age = 10;
    public void show(){
        int b = 30;
        class Inter{
            String name;
            int ID;
            public void method1(){
                System.out.println(age);
                System.out.println(b);
                System.out.println(name);
                System.out.println("局部内部类的method1方法");
            }
        }
        Inter i =new Inter();
        i.method1();
        System.out.println(i.name);
        System.out.println(i.ID);
    }
}

1.9.4 匿名内部类

匿名内部类本质上就是隐藏了名字的内部类

3.格式的细节

• 包含了继承或实现，方法重写，创建对象。
• 整体就是一个类的子类对象或者接口的实现类对象
  4.使用场景
• 当方法的参数是接口或者类时以接口为例，可以传递这个接口的实现类对象如果实现类只要使用一次，就可以用匿名内部类简化代码