6、面向对象编程（下）

已于 2023-03-03 16:43:53 修改
阅读量202 收藏
点赞数
分类专栏： java基础 文章标签： java 开发语言
于 2022-07-03 10:16:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44774198/article/details/125578781
版权

目录

面向对象编程（下）

6.1 关键字：static

1. static 关键字的使用

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上
的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，
其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少
对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个
国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中
都单独分配一个用于代表国家名称的变量。
在这里插入图片描述

  1. static:静态的。
  2. static 可以用来修饰:属性、方法、代码块、内部类。
  3. 使用 static 修饰属性:静态变量(或类变量)。

3.1 属性:是否使用 static 修饰，又分为:静态属性 VS 非静态属性(实例变量)

实例变量:我们创建了类的多个对象，每个对象都独立的拥有了一套类中的非静态属性。
当修改其中一个非静态属性时，不会导致其他对象中同样的属性值的修饰。

静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过静态变量去修改某一个变量时，会导致其他对象调用此静态变量时，是修改过的。

3.2 static 修饰属性的其他说明:
① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用。
② 静态变量的加载要早于对象的创建。
③ 由于类只会加载一次，则静态变量在内存中也只会存在一次。存在方法区的静态域中。
④ 类变量 实例变量
类 yes no
对象 yes yes

3.3 静态属性举例:System.out；Math.PI;

4.使用 static 修饰方法:静态方法

① 随着类的加载而加载，可以通过"类.静态方法"的方式调用
② 静态方法 非静态方法
类 yes no
对象 yes yes
③ 静态方法中，只能调用静态的方法或属性
非静态的方法中，可以调用所有的方法或属性

5.static 注意点:

5.1 在静态的方法内，不能使用 this 关键字、super 关键字
5.2 关于静态属性和静态方法的使用，大家从生命周期的角度去理解。

6.开发中，如何确定一个属性是否需要声明 static 的？

》 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
》 类中的常量也常常声明为 static
开发中，如何确定一个方法是否要声明为 static 的？
》 操作静态属性的方法，通常设置为 static 的
》 工具类中的方法，习惯上声明为 static 的。比如：Math、Arrays、Collections

static静态属性：

public class StaticTest {
    public static void main(String[] args) {

        Chinese.nation = "中国";//随着类的加载而加载，可以使用“类.静态变量”方式调用

        Chinese c1 = new Chinese();
        c1.name = "王五";
        c1.age = 40;
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.name = "张三";
        c2.age = 30;
        c2.nation = "CHINA";

        System.out.println(c1.nation);//CHINA

        //编译不通过
//		Chinese.name = "李四";

    }
}
//中国人
class Chinese{

    String name;
    int age;
    static String nation;
}

输出结果：说明对nation进行了修改。

CHINA

static静态方法：

public class StaticTest {
    public static void main(String[] args) {

        Chinese.nation = "中国";

        Chinese c1 = new Chinese();

        //编译不通过
//		Chinese.name = "张继科";

        c1.eat();

        Chinese.show();
        //编译不通过
//		chinese.eat();//不能使用类调用非静态方法
//		Chinese.info();
    }
}
//中国人
class Chinese{

    String name;
    int age;
    static String nation;

    public void eat(){
        System.out.println("中国人吃中餐");
        //调用非静态结构
        this.info();
        System.out.println("name : " + name);
        //调用静态结构
        walk();
        System.out.println("nation : " + Chinese.nation);
    }

    public static void show(){
        System.out.println("我是一个中国人！");
//		eat();
//		name = "Tom";
        //可以调用静态的结构
        System.out.println(Chinese.nation);
//        System.out.println(nation);//同上等价
//        System.out.println(this.nation);//报错
        walk();
    }

    public void info(){
        System.out.println("name : " + name + ",age : " + age);
    }

    public static void walk(){

    }
}

2. static应用举例和练习

2.1 static 关键字的应用
public class CircleTest {
    public static void main(String[] args) {

        Circle c1 = new Circle();

        Circle c2 = new Circle();

        Circle c3 = new Circle();

        System.out.println("c1 的 ID:" + c1.getId());
        System.out.println("c2 的 ID:" + c2.getId());
        System.out.println("c3 的 ID:" + c3.getId());

        System.out.println("创建圆的个数: " + Circle.getTotal());

    }

}

class Circle{

    private double radius;
    private int id;	//需要自动赋值

    public Circle(){
        id = init++;
        total++;
    }

    public Circle(double radius){
        this();
        //或
//		id = init++;
//		total++;
        this.radius = radius;
    }

    private static int total;//记录创建圆的个数
    private static int init = 1001;//static 声明的属性被所有对象所共享

    public double findArea(){
        return 3.14 * radius * radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public int getId() {
        return id;
    }

    public static int getTotal() {
        return total;
    }

}

运行结果：

c1 的 ID:1001
c2 的 ID:1002
c3 的 ID:1003
创建圆的个数: 3
2.2练习

编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、 “利率”、“最小余额”，定义封装这些属性的方法。
账号要自动生成。编写主类，使用银行账户类，输入、输出 3 个储户的上述信息。
考虑：哪些属性可以设计成 static 属性。


public class Account {

    private int id;	//账号
    private String pwd = "000000";	//密码
    private double balance; //存款余额

    private static double interestRate; //利率
    private static double minMoney = 1.0;  //最小余额
    private static int init = 1001;	//用于自动生成 id

    public Account(){	//账号自动生成
        id = init++;
    }

    public Account(String pwd,double balance){
        id = init++;
        this.pwd = pwd;
        this.balance = balance;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public static double getInterestRate() {
        return interestRate;
    }

    public static void setInterestRate(double interestRate) {
        Account.interestRate = interestRate;
    }

    public static double getMinMoney() {
        return minMoney;
    }

    public static void setMinMoney(double minMoney) {
        Account.minMoney = minMoney;
    }

    public int getId() {
        return id;
    }

    public double getBalance() {
        return balance;
    }

    @Override
    public String toString() {
        return "Account [id=" + id + ", pwd=" + pwd + ", balance=" + balance + "]";
    }

}

测试类

public class AccountTest {
    public static void main(String[] args) {

        Account acct1 = new Account();
        Account acct2 = new Account("qwerty",2000);

        Account.setInterestRate(0.012);
        Account.setMinMoney(100);

        System.out.println(acct1);
        System.out.println(acct2);

        System.out.println(acct1.getInterestRate());
        System.out.println(acct1.getMinMoney());
    }
}

运行结果：

Account [id=1001, pwd=000000, balance=0.0]
Account [id=1002, pwd=qwerty, balance=2000.0]
0.012
100.0

6.2 单例设计模式

1. 设计模式：

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。”套路”

在这里插入图片描述

2. 单例设计模式：

  1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。
  2. 如何实现？
    饿汉式 VS 懒汉式
  3. 区分饿汉式和懒汉式。

饿汉式：
坏处:对象加载时间过长。
好处:饿汉式是线程安全的。
懒汉式：
好处:延迟对象的创建。
坏处:目前的写法，会线程不安全。—>到多线程内容时，再修改
饿汉式：加载类就已经存在
懒汉式：调用方法时才创建对象

2.1 单例的饿汉式
public class SingletonTest {
    public static void main(String[] args) {
//		Bank bank1 = new Bank();
//		Bank bank2 = new Bank();

        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();

        System.out.println(bank1 == bank2);

    }
}

//单例的饿汉式
class Bank{

    //1.私有化类的构造器
    private Bank(){

    }

    //2.内部创见类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态的方法，返回类的对象。
    public static Bank getInstance(){
        return instance;
    }
}
2.2 单例的懒汉式实现：

懒汉式暂时还存在线程安全问题，讲到多线程时，可修复

public class SingletonTest1 {
    public static void main(String[] args) {

        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();

        System.out.println(order1 == order2);
    }
}
class Order{
    //1.私有化类的构造器
    private Order(){

    }

    //2.声明当前类对象，没有初始化。
    //此对象也必须声明为 static 的
    private static Order instance = null;

    //3.声明 public、static 的返回当前类对象的方法
    public static Order getInstance(){
        if(instance == null){
            instance = new Order();
        }
        return instance;
    }
}

3. 单例模式的优点：

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

举例：java.lang中的Runtime
在这里插入图片描述

4. 应用场景：

  • 网站的计数器，一般也是单例模式实现，否则难以同步。
  • 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
  • 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
  • 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
  • Application 也是单例的典型应用
  • Windows的Task Manager (任务管理器)就是很典型的单例模式
  • Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

6.3 类的成员之四：代码块（或初始化块）

  1. 代码块的作用：用来初始化类、对象的
  2. 代码块如果有修饰的话，只能使用 static
  3. 分类:静态代码块 vs 非静态代码块
  4. 静态代码块

内部可以有输出语句
随着类的加载而执行,而且只执行一次
作用:初始化类的信息
如果一个类中，定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行，优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

  1. 非静态代码块

内部可以有输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块。
作用:可以在创建对象时，对对象的属性等进行初始化。
如果一个类中，定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法。

1. 对属性可以赋值的位置:

①默认初始化
②显式初始化
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。
⑤在代码块中赋值

public class BlockTest {
    public static void main(String[] args) {

        String desc = Person.desc;
        System.out.println(desc);

        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(p1.age);

        Person.info();
    }
}

class Person{
    //属性
    String name;
    int age;
    static String desc = "我是一个人";

    //构造器
    public Person(){

    }

    //static 的代码块
    static{
        System.out.println("hello,static block-1");
        //调用静态结构
        desc = "我是一个快乐人";
        info();
        //不能调用非静态结构
//		eat();
//		name = "Tom";
    }

    static{
        System.out.println("hello,static block-2");
    }

    //非 static 的代码块
    {
        System.out.println("hello,block-2");
    }
    {
        System.out.println("hello,block-1");
        //调用非静态结构
        age = 1;
        eat();
        //调用静态结构
        desc = "我是一个爱小说的人 1";
        info();
    }

    //方法
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("吃饭");
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public static void info(){
        System.out.println("我是一个快乐的人。");
    }

}

输出结果：

hello,static block-1
我是一个快乐的人。11
hello,static block-2
我是一个快乐的人
hello,block-2
hello,block-1
吃饭
我是一个快乐的人。11
hello,block-2
hello,block-1
吃饭
我是一个快乐的人。11
1
我是一个快乐的人。11

2. 代码块练习

练习1：

总结:由父类到子类，静态先行

//总结:由父类到子类，静态先行
class Root{
    static{
        System.out.println("Root 的静态初始化块");
    }
    {
        System.out.println("Root 的普通初始化块");
    }
    public Root(){
        System.out.println("Root 的无参数的构造器");
    }
}
class Mid extends Root{
    static{
        System.out.println("Mid 的静态初始化块");
    }
    {
        System.out.println("Mid 的普通初始化块");
    }
    public Mid(){
        System.out.println("Mid 的无参数的构造器");
    }
    public Mid(String msg){
        //通过 this 调用同一类中重载的构造器
        this();
        System.out.println("Mid 的带参数构造器，其参数值："
                + msg);
    }
}
class Leaf extends Mid{
    static{
        System.out.println("Leaf 的静态初始化块");
    }
    {
        System.out.println("Leaf 的普通初始化块");
    }
    public Leaf(){
        //通过 super 调用父类中有一个字符串参数的构造器
        super("猿白");
        System.out.println("Leaf 的构造器");
    }
}
public class LeafTest{
    public static void main(String[] args){
        new Leaf();
        //new Leaf();
    }
}

输出结果：

Root 的静态初始化块
Mid 的静态初始化块
Leaf 的静态初始化块
Root 的普通初始化块
Root 的无参数的构造器
Mid 的普通初始化块
Mid 的无参数的构造器
Mid 的带参数构造器，其参数值：尚硅谷
Leaf 的普通初始化块
Leaf 的构造器

在这里插入图片描述
从object类到root类到mid类到leaf类，静态代码块先跑一遍

练习2：
class Father {
    static {
        System.out.println("11111111111");
    }
    {
        System.out.println("22222222222");
    }

    public Father() {
        System.out.println("33333333333");

    }

}

public class Son extends Father {
    static {
        System.out.println("44444444444");
    }
    {
        System.out.println("55555555555");
    }
    public Son() {
        System.out.println("66666666666");
    }

    public static void main(String[] args) { // 由父及子 静态先行
        System.out.println("77777777777");
        System.out.println("************************");
        new Son();
        System.out.println("************************");

        new Son();
        System.out.println("************************");
        new Father();
    }

}

输出结果：

11111111111
44444444444
77777777777
************************
22222222222
33333333333
55555555555
66666666666
************************
22222222222
33333333333
55555555555
66666666666
************************
22222222222
33333333333

测试：

 public static void main(String[] args) { // 由父及子 静态先行
        System.out.println("77777777777");
//        System.out.println("************************");
//        new Son();
//        System.out.println("************************");
//
//        new Son();
//        System.out.println("************************");
//        new Father();
    }

输出结果：

11111111111
44444444444
77777777777

测试2：

    public static void main(String[] args) { // 由父及子 静态先行
        System.out.println("77777777777");
        System.out.println("************************");
        new Son();
        System.out.println("************************");

        new Son();
//        System.out.println("************************");
//        new Father();
    }

输出结果：

11111111111
44444444444
77777777777
************************
22222222222
33333333333
55555555555
66666666666
************************
22222222222
33333333333
55555555555
66666666666

6.4 关键字：final

1. final关键字

在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。

final标记的类不能被继承。提高安全性，提高程序的可读性。
比如：String类、System类、StringBuffer类

final标记的方法不能被子类重写。
比如：Object类中的getClass()。
在这里插入图片描述

final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只 能被赋值一次。
final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋
值，然后才能使用。
final double MY_PI = 3.14;

final:最终的
1.final可以用来修饰的结构:类、方法、变量
2.final用来修饰一个类:此类不能被其他类所继承。
比如:String类、System类、StringBuffer类
3.final修饰一个方法:final标记的方法不能被子类重写。
比如：Object类中的getClass()。
4.final用来修饰变量:此时的"变量"(成员变量或局部变量)就是一个常量。名称大写，且只能被赋值一次。
4.1 final修饰属性，可以考虑赋值的位置有:显式初始化、代码块中初始化、构造器中初始化
4.2 final修饰局部变量:
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。
一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
static final 用来修饰:全局常量

在这里插入图片描述

final class FianlA{

}

//class B extends FinalA{     //错误，不能被继承。
//
//}

在这里插入图片描述

class AA{
    public final void show(){

    }
}

//class BB extends AA{	// 错误，不能被重写。
//	public void show(){
//
//	}
//}

在这里插入图片描述

 final int WIDTH = 0;
    public void dowidth(){
//		width = 20;	//width cannot be resolved to a variable
    }

完整代码：

public class FinalTest {

    final int WIDTH = 0;
    final int LEFT;
    final int RIGHT;
//	final int DOWN;

    {
        LEFT = 1;
    }

    public FinalTest(){
        RIGHT = 2;
    }

    public FinalTest(int n){
        RIGHT = n;
    }

//	public void setDown(int down){
//		this.DOWN = down;
//	}

    public void dowidth(){
//		width = 20;	//width cannot be resolved to a variable
    }

    public void show(){
        final int NUM = 10;	//常量
//		num += 20;
    }

    public void show(final int num){
        System.out.println(num);
    }

    public static void main(String[] args) {

        int num = 10;

        num = num + 5;

        FinalTest test = new FinalTest();
//		test.setDown(5);

        test.show(10);
    }
}

final class FianlA{

}

//class B extends FinalA{     //错误，不能被继承。
//
//}

//class C extends String{
//
//}

class AA{
    public final void show(){

    }
}

//class BB extends AA{	// 错误，不能被重写。
//	public void show(){
//
//	}
//}

2. 面试题：

在这里插入图片描述

o是常量，但是可以对i赋值

6.5 抽象类与抽象方法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

在这里插入图片描述

1. abstract 关键字的使用

  1. abstract:抽象的
  2. abstract 可以用来修饰的结构:类、方法
  3. abstract 修饰类:抽象类

此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化全过程)
开发中，都会提供抽象类的子类，让子类对象实例化，实现相关的操作

  1. abstract 修饰方法:抽象方法

抽象方法，只有方法的声明，没有方法体。
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
若子类重写了父类中所有的抽象方法，此子类方可实例化
若子类没有重写了父类中所有的抽象方法，此子类也是一个抽象类

2. abstract 使用上的注意点:

  1. abstract 不能用来修饰变量、代码块、构造器；
  2. abstract 不能用来修饰私有方法、静态方法、final 的方法、final 的类。

在这里插入图片描述

  1. 不能实例化
abstract class Person {
    String name;
    int age;

    public Person(){

    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //不是抽象方法
	public void eat(){
		System.out.println("人吃饭");
	}
}

    public static void main(String[] args) {
        //一旦 Person 类抽象了，就不可实例化
		Person p1 = new Person();
		p1.eat();

    }
  1. 抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化全过程)
class Student extends Person{
    public Student(String name,int age){
        super(name,age);
    }
    }
  1. 抽象方法：
    //不是抽象方法，只是空方法体
	public void eat(){}
	//抽象方法,只有方法的声明，没有方法体
	public abstract void eat();
  1. 包含抽象方法的类一定是一个抽象类，反之，抽象类中可以没有抽象方法
abstract class Person {
public abstract void eat();
}

完整代码：

public class AbstractTest {
    public static void main(String[] args) {
        //一旦 Person 类抽象了，就不可实例化
//		Person p1 = new Person();
//		p1.eat();

    }
}

abstract class Creature{
    public abstract void breath();
}

abstract class Person extends Creature{
    String name;
    int age;

    public Person(){

    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //不是抽象方法
//	public void eat(){
//		System.out.println("人吃饭");
//	}

    //抽象方法
    public abstract void eat();

    public void walk(){
        System.out.println("人走路");
    }
}

class Student extends Person{
    public Student(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("学生应该多吃有营养的。");
    }
    @Override
    public void breath() {
        System.out.println("学生应该呼吸新鲜的无雾霾空气");
    }
}

3. 抽象的应用场景

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。在这里插入图片描述

在航运公司系统中，Vehicle类需要定义两个方法分别计算运输工具的燃料效率和行驶距离。

问题：卡车(Truck)和驳船(RiverBarge)的燃料效率和行驶距离的计算方法完全不同。Vehicle类不能提供计算方法，但子类可以。

解决方案：

Java 允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提 供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。

Vehicle 是一个抽象类，有两个抽象方法。

注意：抽象类不能实例化 new Vihicle()是非法的

public abstract class Vehicle{
    public abstract double calcFuelEfficiency();//计算燃料效率的抽象方法
    public abstract double calcTripDistance();//计算行驶距离的抽象方法
}
public class Truck extends Vehicle{
    public double calcFuelEfficiency(){
        //写出计算卡车的燃料效率的具体方法
    }
    public double calcTripDistance(){
        //写出计算卡车行驶距离的具体方法
    }
}
public class RiverBarge extends Vehicle{
    public double calcFuelEfficiency() {
        //写出计算驳船的燃料效率的具体方法
    }
    public double calcTripDistance( )  {
        //写出计算驳船行驶距离的具体方法
    }
}
练习

编写一个Employee类，声明为抽象类，
包含如下三个属性：name，id，salary。
提供必要的构造器和抽象方法：work()。
对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。
请使用继承的思想，设计CommonEmployee类和Manager类，要求类
中提供必要的方法进行属性访问。

Employee类
public abstract class Employee {

    private String name;
    private int id;
    private double salary;

    public Employee(){
        super();
    }

    public Employee(String name, int id, double salary) {
        super();
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public abstract void work();
}
Manager类

对于 Manager 类来说，他既是员工，还具有奖金(bonus)的属性。

public class Manager extends Employee{

    private double bonus;	//奖金

    public Manager(double bonus) {
        super();
        this.bonus = bonus;
    }

    public Manager(String name, int id, double salary, double bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }


    @Override
    public void work() {
        System.out.println("管理员工，提高公司运行效率。");
    }
}
CommonEmployee类
public class CommonEmployee extends Employee {

    @Override
    public void work() {
        System.out.println("员工在一线车间生产产品。");
    }

}
EmployeeTest类

请使用继承的思想，设计 CommonEmployee 类和 Manager 类，要求类中必须提供必要的方法进行属性访问

public class EmployeeTest {
    public static void main(String[] args) {

        Employee manager = new Manager("库克",1001,5000,50000);

        manager.work();

        CommonEmployee commonEmployee = new CommonEmployee();
        commonEmployee.work();
    }
}

6.6 模板方法设计模式及应用场景（多态的应用）

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模
板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象
类的行为方式。

解决的问题：

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

练习1
/*
 * 抽象类的应用:模板方法的设计模式
 */
public class TemplateTest {
	public static void main(String[] args) {
		
		SubTemlate t = new SubTemlate();
		
		t.sendTime();
	}
}
abstract class Template{
	
	//计算某段代码执行所需花费的时间
	public void sendTime(){
		
		long start = System.currentTimeMillis();
		
		code();	//不确定部分，易变的部分
		
		long end = System.currentTimeMillis();
		
		System.out.println("花费的时间为:" + (end - start));
	}
	
	public abstract void code();
}

class SubTemlate extends Template{
	
	@Override
	public void code() {
		
		for(int i = 2;i <= 1000;i++){
			boolean isFlag = true;
			for(int j = 2;j <= Math.sqrt(i);j++){
				if(i % j == 0){
					isFlag = false;
					break;
				}
			}
			if(isFlag){
				System.out.println(i);
			}
		}
	}
}
练习2
//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {

	public static void main(String[] args) {
		BankTemplateMethod btm = new DrawMoney();
		btm.process();

		BankTemplateMethod btm2 = new ManageMoney();
		btm2.process();
	}
}
abstract class BankTemplateMethod {
	// 具体方法
	public void takeNumber() {
		System.out.println("取号排队");
	}

	public abstract void transact(); // 办理具体的业务 //钩子方法

	public void evaluate() {
		System.out.println("反馈评分");
	}

	// 模板方法，把基本操作组合到一起，子类一般不能重写
	public final void process() {
		this.takeNumber();

		this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码

		this.evaluate();
	}
}

class DrawMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要取款！！！");
	}
}

class ManageMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要理财！我这里有 2000 万美元!!");
	}
}

模板方法设计模式是编程中经常用得到的模式。各个框架、类库中都有他的
影子，比如常见的有：
数据库访问的封装
Junit单元测试
JavaWeb的Servlet中关于doGet/doPost方法调用
Hibernate中模板程序
Spring中JDBCTemlate、HibernateTemplate等

6.7 接口

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则
必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能" 的关系。

接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都
要遵守

1. 接口(interface)是抽象方法和常量值定义的集合。

2. 接口的特点：

  • 用 interface 来定义。
  • 接口中的所有成员变量都默认是由 public static final 修饰的。
  • 接口中的所有抽象方法都默认是由 public abstract 修饰的。
  • 接口中没有构造器。
  • 接口采用多继承机制。

3. 接口举例：

在这里插入图片描述
在这里插入图片描述

4. 接口的使用

  • 1.接口使用 interface 来定义。
  • 2.在 Java 中:接口和类是并列的两个结构
  • 3.如何去定义两个接口:定义接口中的成员

3.1 JDK7 及以前:只能定义全局常量和抽象方法

全局常量:public static final 的,但是书写中，可以省略不写。

//全局变量
  public static final int MAX_SPEED = 7900;
  int MIN_SPEED = 1;//省略了 public static final

抽象方法:public abstract 的

//抽象方法
    public abstract void fly();

    void stop();//省略了 public abstract

3.2 JDK8:除了全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)。

  • 4.接口中不能定义构造器！意味着接口不可以实例化。
//	public Flayable(){
//
//	}
  • 5.Java 开发中，接口通过让类去实现(implements)的方式来使用。

如果实现类覆盖了接口中的所有方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

class Plane implements Flayable{

    @Override
    public void fly() {
        System.out.println("飞机通过引擎起飞");

    }

    @Override
    public void stop() {
        System.out.println("驾驶员减速停止");
    }

}

只实现了一个抽象方法（此类仍然为抽象类abstract）：

abstract class Kite implements Flayable{

    @Override
    public void fly() {

    }
}
  • 6.Java 类可以实现多个接口 —>弥补了 Java 单继承性的局限性

格式:class AA extends BB implementd CC,DD,EE

class Bullet extends Object implements Flayable,Attackable,CC{}
  • 7.接口与接口之间是继承,而且可以多继承

  • 8.接口的具体使用，体现多态性
    接口的主要用途就是被实现类实现。（面向接口编程）

  • 9.接口，实际可以看作是一种规范

  • 面试题:抽象类与接口有哪些异同？

完整代码：

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flayable.MAX_SPEED);
        System.out.println(Flayable.MIN_SPEED);
    }
}
interface Flayable{

    //全局变量
    public static final int MAX_SPEED = 7900;
    int MIN_SPEED = 1;//省略了 public static final

    //抽象方法
    public abstract void fly();

    void stop();//省略了 public abstract
    //Interfaces cannot have constructors
//	public Flayable(){
//
//	}
}
interface Attackable{
    void attack();
}

class Plane implements Flayable{

    @Override
    public void fly() {
        System.out.println("飞机通过引擎起飞");

    }

    @Override
    public void stop() {
        System.out.println("驾驶员减速停止");
    }

}
abstract class Kite implements Flayable{

    @Override
    public void fly() {

    }
}

class Bullet extends Object implements Flayable,Attackable,CC{

    @Override
    public void attack() {
        // TODO Auto-generated method stub

    }

    @Override
    public void fly() {
        // TODO Auto-generated method stub

    }

    @Override
    public void stop() {
        // TODO Auto-generated method stub

    }

    @Override
    public void method1() {
        // TODO Auto-generated method stub

    }

    @Override
    public void method2() {
        // TODO Auto-generated method stub

    }
}

//*********************************
interface AA{
    void method1();
}
interface BB{
    void method2();
}
interface CC extends AA,BB{

}
  1. 接口使用上也满足多态性
  2. 接口，实际上就是定义了一种规范
  3. 开发中，体会面向接口编程！
    在这里插入图片描述
多态性：
interface USB{
    //常量:定义了长、宽、最大最小传输速度等
    void start();

    void stop();
}
class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U 盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U 盘结束工作");
    }
}
class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开启工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }

}

computer：

class Computer{

    public void transferData(USB usb){//USB usb = new Flash();
        usb.start();

        System.out.println("具体传输数据的细节");

        usb.stop();
    }

}

多态性：

 		Computer com = new Computer();
        Flash flash = new Flash();
        com.transferData(flash);
创建接口匿名实现类的对象
Computer com = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        com.transferData(flash);
        //2. 创建了接口的非匿名实现类的匿名对象
        com.transferData(new Printer());
        //3. 创建了接口的匿名实现类的非匿名对象
        USB phone = new USB(){

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }

        };
        com.transferData(phone);
        //4. 创建了接口的匿名实现类的匿名对象
        com.transferData(new USB(){
            @Override
            public void start() {
                System.out.println("mp3 开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3 结束工作");
            }
        });

完整代码：

/*
 * 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程！
 *
 */
public class USBTest {
    public static void main(String[] args) {

        Computer com = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        com.transferData(flash);
        //2. 创建了接口的非匿名实现类的匿名对象
        com.transferData(new Printer());
        //3. 创建了接口的匿名实现类的非匿名对象
        USB phone = new USB(){

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }

        };
        com.transferData(phone);
        //4. 创建了接口的匿名实现类的匿名对象
        com.transferData(new USB(){
            @Override
            public void start() {
                System.out.println("mp3 开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3 结束工作");
            }
        });
    }
}

class Computer{

    public void transferData(USB usb){//USB usb = new Flash();
        usb.start();

        System.out.println("具体传输数据的细节");

        usb.stop();
    }

}

interface USB{
    //常量:定义了长、宽、最大最小传输速度等
    void start();

    void stop();
}
class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U 盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U 盘结束工作");
    }
}
class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开启工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }

}

5. 接口的应用：代理模式

1. 概述：

代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问在这里插入图片描述

2. 举例：

接口：

interface NetWork{
    public void browse();

}

被代理类：

class Server implements NetWork{


    @Override
    public void browse() {
        System.out.println("真实的服务器来访问网络");
    }
}

代理类：

class ProxyServer implements NetWork{

    private NetWork work;

    public ProxyServer(NetWork work){
        this.work = work;
    }

    public void check(){
        System.out.println("联网前的检查工作");
    }

    @Override
    public void browse() {
        check();

        work.browse();
    }

}

主函数：通郭proxy进行代理

		Server server = new Server();
//		server.browse();
        ProxyServer proxyServer = new ProxyServer(server);

        proxyServer.browse();

完整代码：

package 面向对象_下.k接口;

/**
 * @Projectname java_based
 * @Filename NetWorkTest
 * @Author an
 * @Data 2022/7/6 8:03
 * @Description TODO
 */
/*
 * 接口的应用:代理模式
 *
 *
 */
public class NetWorkTest {
    public static void main(String[] args) {

        Server server = new Server();
//		server.browse();
        ProxyServer proxyServer = new ProxyServer(server);

        proxyServer.browse();
    }
}
interface NetWork{
    public void browse();

}
//被代理类
class Server implements NetWork{


    @Override
    public void browse() {
        System.out.println("真实的服务器来访问网络");
    }
}
//代理类
class ProxyServer implements NetWork{

    private NetWork work;

    public ProxyServer(NetWork work){
        this.work = work;
    }

    public void check(){
        System.out.println("联网前的检查工作");
    }

    @Override
    public void browse() {
        check();

        work.browse();
    }

}

输出结果：

联网前的检查工作
真实的服务器来访问网络
3. 应用场景：

安全代理：屏蔽对真实角色的直接访问。

远程代理：通过代理类处理远程方法调用（RMI）

延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象
比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

4. 分类：

静态代理（静态定义代理类）

动态代理（动态生成代理类）

JDK自带的动态代理，需要反射等知识

5. 静态代理：
public class StaticProxyTest {

    public static void main(String[] args) {
        Proxy s = new Proxy(new RealStar());
        s.confer();
        s.signContract();
        s.bookTicket();
        s.sing();
        s.collectMoney();
    }
}

interface Star {
    void confer();// 面谈

    void signContract();// 签合同

    void bookTicket();// 订票

    void sing();// 唱歌

    void collectMoney();// 收钱
}
//被代理类
class RealStar implements Star {

    public void confer() {
    }

    public void signContract() {
    }

    public void bookTicket() {
    }

    public void sing() {
        System.out.println("明星：歌唱~~~");
    }

    public void collectMoney() {
    }
}

//代理类
class Proxy implements Star {
    private Star real;

    public Proxy(Star real) {
        this.real = real;
    }

    public void confer() {
        System.out.println("经纪人面谈");
    }

    public void signContract() {
        System.out.println("经纪人签合同");
    }

    public void bookTicket() {
        System.out.println("经纪人订票");
    }

    public void sing() {
        real.sing();
    }

    public void collectMoney() {
        System.out.println("经纪人收钱");
    }
}

输出结果：

经纪人面谈
经纪人签合同
经纪人订票
明星：歌唱~~~
经纪人收钱

6. 接口的应用：工厂模式

实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

其实设计模式和面向对象设计原则都是为了使得开发项目更加容易扩展和维护，解决方式就是一个“分工”。
社会的发展也是这样，分工越来越细。
原始社会的人：人什么都要会，自己种，自己打猎，自己织衣服，自己治病
现在的人：可以只会一样，其他都不会，只会 Java 也能活，不会做饭，不会开
车，不会…

1. 面向对象的设计模式：

（总共六个）：这里说几个和工厂模式相关的

1.1 OCP（开闭原则，Open-Closed Principle）

一个软件的实体应当对扩展开放，对修改关闭。
当我们写完的代码，不能因为需求变化就修改。我们可以通过新增代码的方式来解决变化的需求。如果每次需求变动都去修改原有的代码，那原有的代码就存在被修改错误的风险，当然这其中存在有意和无意的修改，都会导致原有正常运行的功能失效的风险，这样很有可能会展开可怕的蝴蝶效应，使维护工作剧增。
说到底，开闭原则除了表面上的可扩展性强以外，在企业中更看重的是维护成本。
所以，开闭原则是设计模式的第一大原则，它的潜台词是：控制需求变动风险，缩小维护成本。

1.2 DIP（依赖倒转原则，Dependence Inversion Principle）

要针对接口编程，不要针对实现编程。
如果 A 中关联 B，那么尽量使得 B 实现某个接口，然后 A 与接口发生关系，不与 B 实现类发生关联关系。
依赖倒置的潜台词是：面向抽象编程，解耦调用和被调用者。

1.3 LOD（迪米特法则，Law Of Demeter）

只与你直接的朋友通信，而避免和陌生人通信。
要求尽量的封装，尽量的独立，尽量的使用低级别的访问修饰符。这是封装特性的典型体现。
一个类如果暴露太多私用的方法和字段，会让调用者很茫然。并且会给类造成不必要的判断代码。所以，我们使用尽量低的访问修饰符，让外界不知道我们的内部。这也是面向对象的基本思路。这是迪米特原则的一个特性，无法了解类更多的私有信息。
另外，迪米特原则要求类之间的直接联系尽量的少，两个类的访问，通过第三个中介类来实现。
迪米特原则的潜台词是：不和陌生人说话，有事去中介。

2. 工厂模式的分类：
  • 简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，
    需要修改已有代码）
  • 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
  • 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无
    能为力；支持增加产品族）

GOF 在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory
Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple
Factory）看为工厂方法模式的一种特例，两者归为一类。

核心本质:

实例化对象，用工厂方法代替 new 操作。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

2.1 无工厂模式
interface Car{
void run();
}
class Audi implements Car{
public void run() {
System.out.println("奥迪在跑");
}
}
class BYD implements Car{
public void run() {
System.out.println("比亚迪在跑");
}
}
public class Client01 {
public static void main(String[] args) {
Car a = new Audi();
Car b = new BYD();
a.run();
b.run();
}
}

在这里插入图片描述

2.2 简单工厂模式

简单工厂模式，从命名上就可以看出这个模式一定很简单。它存在的目的很简单：
定义一个用于创建对象的工厂类。

interface Car {
void run();
}
class Audi implements Car {
public void run() {
System.out.println("奥迪在跑");
}
}
class BYD implements Car {
public void run() {
System.out.println("比亚迪在跑");
}
}


//工厂类
class CarFactory {
//方式一
public static Car getCar(String type) {
if ("奥迪".equals(type)) {
return new Audi();
} else if ("比亚迪".equals(type)) {
return new BYD();
} else {
return null;
}
}
//方式二
// public static Car getAudi() {
// return new Audi();
// }
//
// public static Car getByd() {
// return new BYD();
// }
}
public class Client02 {
public static void main(String[] args) {
Car a = CarFactory.getCar("奥迪");
a.run();
Car b = CarFactory.getCar("比亚迪");
b.run();
}
}

在这里插入图片描述
调用者只要知道他要什么，从哪里拿，如何创建，不需要知道。分工，多出了一
个专门生产 Car 的实现类对象的工厂类。把调用者与创建者分离。
小结：
简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的
参数的不同来返回不同的实例对象。
缺点：对于增加新产品，不修改代码的话，是无法扩展的。违反了开闭原则（对 扩展开放；对修改封闭）。

2.3 工厂方法模式

为了避免简单工厂模式的缺点，不完全满足 OCP（对扩展开放，对修改关闭）。
工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一 个项目或者一个独立的模块而言）工厂类，而工厂方法模式有一组实现了相同接 口的工厂类。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模
式里不同的工厂子类来分担。

interface Car{
void run();
}
//两个实现类
class Audi implements Car{
public void run() {
System.out.println("奥迪在跑");
}
}
class BYD implements Car{
public void run() {
System.out.println("比亚迪在跑");
}
}
//工厂接口
interface Factory{
Car getCar();
}
//两个工厂类
class AudiFactory implements Factory{
public Audi getCar(){
return new Audi();
}
}
class BydFactory implements Factory{
public BYD getCar(){
return new BYD();
}
}
public class Client {
public static void main(String[] args) {
Car a = new AudiFactory().getCar();
Car b = new BydFactory().getCar();
a.run();
b.run();
}
}

在这里插入图片描述
总结：
简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。在简单工厂模
式中，新产品的加入要修改工厂角色中的判断语句；而在工厂方法模式中，要么
将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就像
上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。
面对这种情况，Java 的反射机制与配置文件的巧妙结合突破了限制——这在 Spring 中完美的体现了出来。

2.4 抽象工厂模式

抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。
抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。
而且使用抽象工厂模式还要满足一下条件：

  1. 系统中有多个产品族，而系统一次只可能消费其中一族产品。
  2. 同属于同一个产品族的产品以其使用。

7. 接口和抽象类之间的对比

在这里插入图片描述
在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类，要么实现接口。

1. 面试题1：排错
interface A {
	int x = 0;
}
class B {
	int x = 1;
}
class C extends B implements A {
	public void pX() {
		System.out.println(x);
	}
	public static void main(String[] args) {
		new C().pX();
	}
}

解答：

interface A {
	int x = 0;
}
class B {
	int x = 1;
}
class C extends B implements A {
	public void pX() {
//		编译不通过，x 不明确
		System.out.println(x);
//		System.out.println(super.x); //1
//		System.out.println(A.x);//0
	}
	public static void main(String[] args) {
		new C().pX();
	}
}
2. 面试题2：排错
interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, 
Bounceable {
Ball ball = new Ball("PingPang");
}

class Ball implements Rollable {
private String name;
public String getName() {
return name;
}
public Ball(String name) {
this.name = name;
}
public void play() {
ball = new Ball("Football");
System.out.println(ball.getName());
}
}


interface Playable {
	void play();
}
interface Bounceable {
	void play();
}
interface Rollable extends Playable, Bounceable {
	Ball ball= new Ball("PingPang"); //省略了 public static final
}
public class Ball implements Rollable {
	private String name;
	public String getName() {
		return name;
	}
	public Ball(String name) {
		this.name= name;
	}
	public void play() {
		ball = new Ball("Football"); //The final field Rollable.ball cannot be assigned	
		System.out.println(ball.getName());
	}
}

8. 接口练习

在这里插入图片描述

1. 定义一个接口用来实现两个对象的比较。
public interface CompareObject {
    public int compareTo(Object o);
    //若返回值是 0,代表相等;若为正数，代表当前对象大；负数代表当前对象小

}
2. 定义一个 Circle 类，声明 redius 属性，提供 getter 和 setter 方法
public class Circle {

    private Double radius;

    public Double getRadius() {
        return radius;
    }

    public void setRadius(Double radius) {
        this.radius = radius;
    }

    public Circle() {
        super();
    }

    public Circle(Double radius) {
        super();
        this.radius = radius;
    }

}
3. 定义一个 ComparableCircle 类，继承 Circle 类并且实现 CompareObject 接口。在 ComparableCircle 类中给出接口中方法 compareTo 的实现体，用来比较两个圆的半径大小。

public class ComparableCircle extends Circle implements CompareObject{

    public ComparableCircle(double radius) {
        super(radius);
    }
    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }
        if(o instanceof ComparableCircle){
            ComparableCircle c = (ComparableCircle)o;
            //错误的写法
//			return (int)(this.getRedius() - c.getRedius());
            //正确的方式一：
//			if(this.getRadius() > c.getRadius()){
//				return 1;
//			}else if(this.getRadius() < c.getRadius()){
//				return -1;
//			}else{
//				return 0;
//			}
            //当属性 radius 声明为 Double 类型时，可以调用包装类的方法
            //正确的方式二：
            return this.getRadius().compareTo(c.getRadius());
        }else{
            return 0;
//			throw new RuntimeException("传入数据类型不匹配");
        }
    }
}
4. 定义一个测试类 InterfaceTest，创建两个 ComparableCircle 对象， 调用 compareTo 方法比较两个类的半径大小。

public class InterfaceTest {
    public static void main(String[] args) {

        ComparableCircle c1 = new ComparableCircle(3.4);
        ComparableCircle c2 = new ComparableCircle(3.6);

        int compareValue = c1.compareTo(c2);
        if(compareValue > 0){
            System.out.println("c1 对象大");
        }else if(compareValue < 0){
            System.out.println("c2 对象大");
        }else{
            System.out.println("两个一样的");
        }

        int compareValue1 = c1.compareTo(new String("AA"));
        System.out.println(compareValue1);
    }
}

9. java8中关于接口的新特性

Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

静态方法：使用static关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。

默认方法：默认方法使用default关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。

1. JDK8:除了全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)
public interface CompareA {

    //静态方法
    public static void method1() {
        System.out.println("CompareA:西安");
    }

    //默认方法
    public default void method2(){
        System.out.println("CompareA:深圳");
    }

    default void method3(){
        System.out.println("CompareA:杭州");
    }
}


public interface CompareB {
    default void method3(){
        System.out.println("CompareB：上海");
    }
}


public class SuperClass {
    public void method3(){
        System.out.println("SuperClass:北京");
    }
}

知识点 1：接口中定义的静态方法，只能通过接口来调用。
知识点 2：通过实现类的对象，可以调用接口中的默认方法。
如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
知识点 3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–>类优先原则
知识点 4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。–>接口冲突。
这就需要我们必须在实现类中重写此方法

2. subclasstest类
public class SubClassTest {

    public static void main(String[] args) {
        SubClass s = new SubClass();
//		s.method1();
//		SubClass.method1();
//		知识点 1：接口中定义的静态方法，只能通过接口来调用。
        CompareA.method1();
//		知识点 2：通过实现类的对象，可以调用接口中的默认方法。
//		如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
        s.method2();
//		知识点 3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
//		那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
//		知识点 4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
//		那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
//		这就需要我们必须在实现类中重写此方法
        s.method3();

    }
}
class SubClass extends SuperClass implements CompareA,CompareB{

    public void method2(){
        System.out.println("SubClass：上海");
    }

    public void method3(){
        System.out.println("SubClass：深圳");
    }

    //	知识点 5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
    public void myMethod(){
        method3(); //调用自己定义的重写的方法
        super.method3(); //调用的是父类中声明的
//		调用接口中的默认方法
        CompareA.super.method3();
        CompareB.super.method3();
    }
}

输出结果：

CompareA:西安
SubClass：上海
SubClass：深圳

若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。

解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。

若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。

3. 练习：接口冲突的解决办法
/*
 * 练习：接口冲突的解决方式
 */
interface Filial {// 孝顺的
	default void help() {
		System.out.println("老妈，我来救你了");
	}
}

interface Spoony {// 痴情的
	default void help() {
		System.out.println("媳妇，别怕，我来了");
	}
}

class Father{
	public void help(){
		System.out.println("儿子，救我媳妇！");
	}
}

class Man extends Father implements Filial, Spoony {

	@Override
	public void help() {
		System.out.println("我该就谁呢？");
		Filial.super.help();
		Spoony.super.help();
	}
	
}

6.8 类的成员之五：内部类

1. 概述

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完
整的名称。
Inner class的名字不能与包含它的外部类类名相同；

2. 分类：

成员内部类（static成员内部类和非static成员内部类）
局部内部类（不谈修饰符）、匿名内部类

  • 1.Java中允许将一个类A声明在另一个类B中,则类A就是内部类,类B就是外部类.
  • 2.内部类的分类:成员内部类（静态、非静态） VS 局部内部类(方法内、代码块内、构造器内)
  • 3.成员内部类

作为外部类的成员,
- 调用外部类的结构
- 可以被static修饰
- 可以被4种不同的权限修饰

作为一个类，
- 类内可以定义属性、方法、构造器等
- 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
- 可以abstract修饰

  • 4.关注如下的3个问题

如何实例化成员内部类的对象

        //创建Dog实例(静态的成员内部类)
        Person.Dog dog = new Person.Dog();
        dog.show();

        //创建Bird实例(非静态的成员内部类)
//		Person.Bird bird = new Person.Bird();
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        bird.sing();

如何在成员内部类中区分调用外部类的结构

        public void display(String name){
            System.out.println(name);	//方法的形参
            System.out.println(this.name);	//内部类的属性
            System.out.println(Person.this.name);	//外部类的属性
        }

开发中局部内部类的使用 见《InnerClassTest1.java》

public class InnerClassTest1 {
	
//	开发中很少见
	public void method(){
//		局部内部类
		class AA{
			
		}
	}
	
//	返回一个实现了Comparable接口的类的对象
	public Comparable getComparable(){
		
//		创建一个实现了Comparable接口的类:局部内部类
		//方式一：
//		class MyComparable implements Comparable{
//
//			@Override
//			public int compareTo(Object o) {
//				return 0;
//			}
//			
//		}
//		
//		return new MyComparable();
		
		//方式二：匿名
		return new Comparable(){


			@Override
			public int compareTo(Object o) {
				return 0;
			}
			
		};
		
	}
}

3. 局部内部类和成员内部类

class Person{
		//静态成员内部类
		static class Dog{
		}
		//非静态成员内部类
		class Cat{
		}
 public void method(){
        //局部内部类
        class AA{

        }
    }
}

public class InnerClassTest {
    public static void main(String[] args) {

        //创建Dog实例(静态的成员内部类)
        Person.Dog dog = new Person.Dog();
        dog.show();

        //创建Bird实例(非静态的成员内部类)
//		Person.Bird bird = new Person.Bird();
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        bird.sing();

        System.out.println();

        bird.display("喜鹊");
    }
}
class Person{
    String name = "李雷";
    int age;

    public void eat(){
        System.out.println("人，吃饭");
    }

    //静态成员内部类
    static class Dog{
        String name;
        int age;

        public void show(){
            System.out.println("卡拉是条狗");
//			eat();
        }
    }

    //非静态成员内部类
    class Bird{
        String name = "杜鹃";
        public Bird(){

        }

        public void sing(){
            System.out.println("我是一只猫头鹰");
            Person.this.eat();//调用外部类的非静态属性
            eat();
            System.out.println(age);
        }

        public void display(String name){
            System.out.println(name);	//方法的形参
            System.out.println(this.name);	//内部类的属性
            System.out.println(Person.this.name);	//外部类的属性
        }
    }
    public void method(){
        //局部内部类
        class AA{

        }
    }

    {
        //局部内部类
        class BB{

        }
    }

    public Person(){
        //局部内部类
        class CC{

        }
    }
}
猿 白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何理解Python 面向对象编程思想
qq_39519084的博客
02-17 2万+
Python 面向对象编程思想：从四个方面来理解1. 宽泛的面向对象的概念 举例说明面向过程：做一件事情，从头到尾，每一个细节都要关注，重点在于过程面向对象：做一件事情，用对象去做，不关心细节和过程，万物皆对象
C语言实现面向对象编程
02-24
面向对象编程（OOP）并不是一种特定的语言或者工具，它只是一种设计方法、设计思想。它表现出来的三个最基本的特性就是封装、继承与多态。很多面向对象的编程语言已经包含这三个特性了，例如Smalltalk、C++、Java。...
6.Static类
你好啊cbw
01-15 500
6.Static类 6.1.静态static关键字概述 1.学生类(姓名，年龄，学号，所在教室)； 学生对象(姓名，年龄，学号，所在教室)； 2.对于姓名、年龄、学号来说，每一个对象都要自己独立的数据。 3.对于所在教室，这些对象都在同一个教室，应该共享同一份数据，而不是每个对象都要有教室属性。 4.因此，要求只在类中保存唯一一份，那所有本类的对象共享同一份数据。 5.一旦使用static关键字，那么该内容不再属于对象自己，而是属于类，所以本类所有对象共享该内容，谁都可以任意更改这个内容。 6.2
day6-09 继承中静态成员的处理
weixin_42503072的博客
05-29 86
内容难点 重点：静态成员变量是所有对象共用的，只有一份，不会为每一个对象都分配一个不同的值。然而我以前一直理解的是静态成员变量是所以类共用，这次真的学到了。 继承中类似非静态成员函数处理 如果想访问父类中的成员，加作用域即可 代码 #define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; class Base { public: static void func() { cout <&lt
6-1面向对象编程（下）----关键字：static
wp_886的博客
01-29 85
关键字：static 一、static关键字的引入说明 在编写一个类的时候，其实就是在描述其对象的属性和行为，本质上并没有产生对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。 我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。 二、static关键字的使用 1.static:静态
java中的static属性详细介绍
忆往昔的博客
01-14 7511
java中静态代码块 静态代码块的特点: 随着类的加载而执行，而且只执行一次 https://www.baidu.com/s?wd=java%E9%9D%99%E6%80%81%E4%BB%A3%E7%A0%81%E5%9D%97 https://recomm.cnblogs.com/blogpost/6907471 https://zhidao.baidu.com/question/393900964.html https://www.cnblogs.com/twlqx/p/4430135.html ht
关于static关键字的使用以及与成员方法、成员属性的总结
iteye_12166的博客
12-03 138
static表示“静态的”或者“全局的”，用来修饰变量，属性，方法。 1、静态属性[静态域] 当static修饰属性的时候，是该类的所有对象共享的一个属性，只会占有一块内存空间，可以通过对象，或者类名直接调用。 [code="java"]public static B b= new B();[/code] 2、静态方法 当static修饰方法时，由于是直接通过类名调用，所...
Python 面向对象编程详解
CSDN
08-04 6476
面向对象,OOP英文全称(Object-Oriented Programming)是一种高效的编程思路,面向对象技术已经成为当今软件设计和开发领域的主流技术,面向对象编程是一种编程方式,使用 "类" 和 "对象" 来实现,所以面向对象编程其实就是对 "类" 和 "对象" 的使用,类就是一个模板,模板里可以包含多个方法(函数),方法里实现各种各样的功能,对象则是根据模板创建的实例,通过实例对象可以执行类中的方法,每个对象都拥有相同的方法,但各自的数据可能不同.
什么叫面向对象编程？
weixin_38982114的博客
03-17 1783
面向对象编程是一种设计思想，它是现实世界的抽象，任何现实世界中的事物都可以用面向对象思想来解决。“万物皆对象”，JavaScript中不是面向对象编程。而是面向函数编程，这里，JavaScript中函数是“一等公民”，那什么又是“一等公民”呢？就是函数和整数、字符串等常见概念的地位是平等的，一个整数和一个字符串等对象可以干的事，一个函数也可以办到。 面向对象我们经常和面向过程做比较，面向过程是C语言编程的核心思想 面向对象注重于抽象事物，而面向过程注重于描述事物 面向对象逻辑清晰有条理，而面向过程比较方面
C 语言实现面向对象编程
热门推荐
onlyshi的专栏
08-14 5万+
C 语言实现面向对象编程 1、引言 面向对象编程（OOP）并不是一种特定的语言或者工具，它只是一种设计方法、设计思想。它表现出来的三个最基本的特性就是封装、继承与多态。很多面向对象的编程语言已经包含这三个特性了，例如 Smalltalk、C++、Java。但是你也可以用几乎所有的编程语言来实现面向对象编程，例如 ANSI-C。要记住，面向对象是一种思想，一种方法，不要太拘泥于编程语言。...
python之面向对象编程
qq_43428929的博客
08-23 1426
面向对象程序设计面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是种具有对象概念的编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、特性、代码与方法。对象则指的是类（class）的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的对象。从维基百科的定义可以看出，面向对象编程的对象。
plc面向对象编程架构与实现
01-19
面向对象编程是计算机语言的一种先进的编程模式，在工业控制系统的PLC程序中也可以采用这种设计思想，虽然我们无法实现面向对象的很多特点如“继承”，甚至于它根本就不具备面向对象编程语言的特点，但面向对象编程...
Labview面向对象编程快速入门.pdf
05-11
Labview面向对象编程快速入门
面向对象编程思想.ppt
11-15
面向对象编程思想 面向对象编程（Object Oriented Programming，简称OOP）描述的是对象之间的相互作用。面向对象编程思想是现代软件开发的基础之一，它强调的是对象之间的交互和协作，而不是简单地编写一系列的函数...
Java内存模型
最新发布
weixin_44267758的博客
07-19 316
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 588
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 847
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 898
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 504
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
Java面向对象编程详解
"面向对象编程（Java）的PDF文档包含了面向对象编程的所有基础知识和实战代码，主要涉及Java语言，涵盖的概念包括面向对象编程的定义、特点、三大特性（封装、继承和多态），以及相关的编程实践，如方法调用、构造器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值