Java 第六章 面向对象编程（下）

Java 第六章 面向对象编程（下）

在这里插入图片描述

一、关键字：static

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

1.static：静态的

2.static可以用来修饰：属性、方法、代码块、内部类

3.使用static修饰属性：静态变量（eg.Math.PI,）
属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性（实例变量）
实例变量：当创建了类的多个对象时，每个对象都独立的拥有一套类中的非静态属性。当修改其中某个对象的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：当创建了类的多个对象时，多个对象共享同一个静态变量。当通过某个对象修改静态变量时，会导致其他对象调用此静态变量时，发生修改
静态变量的其它说明：①随着类的加载而加载，可通过“类.静态变量”的方式进行调用。②早于对象的创建。③由于类只会加载一次，则静态变量在内存中只有一份：存在方法区的静态域中
在这里插入图片描述

4.使用static修饰方法：静态方法
①随着类的加载而加载，可以通过“类.静态方法”的方式进行调用
②静态方法中，只能调用静态方法或属性；非静态方法中，可以调用静态或非静态的方法或属性
③静态方法中，不能使用this、super关键字

5.如何确定某个属性是否要声明为static的？

该属性是可以被多个对象所共享的，不会随着对象的不同而不同的

6.如何确定某个方法是否要声明为static的？

操作静态属性的方法，通常设为static的
工具类中的方法，习惯上声明为static的。eg：Math、Arrays、Collections

7.单例（Singleton）设计模式

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

所谓单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类的内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例设计模式的好处

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

单例设计模式的应用场景

在这里插入图片描述

单例的饿汉式实现

public class bank
{
    private bank()//1.私有化类的构造器
    {

    }
    private static bank instance = new bank();//2.内部创建类的对象，
    //要求此对象也是静态的
    public static bank getInstance()
    {
        return instance;//3.提供公共的静态的方法，返回类的对象
    }
}
public class singletonTest
{
    public static void main(String[] args)
    {
        bank Bank1 = bank.getInstance();
        bank Bank2 = bank.getInstance();
        System.out.println(Bank1==Bank2);//true
    }
}

单例的懒汉式实现

public class order
{
   private order()//1.私有化类的构造器
   {

   }
   //2.声明当前类的对象，没有初始化
   private static order instance = null;
   public static order getInstance()
   //3.声明private、public的返回当前类对象的方法
   {
       if(instance == null)
       {
           instance = new order();
       }
       return instance;
   }
}

区分饿汉式和懒汉式

饿汉式
坏处：对象加载时间过长
好处：天然线程安全的

懒汉式
好处：延迟对象的创建
坏处：目前写法是线程不安全的 --->多线程内容时再修改

二、理解main()方法的使用

1.main()方法作为程序的入口
2.main()方法也是一个普通的静态方法

public class main
{
    public static void main(String[] args) {
        for(int i=0;i<args.length;i++)
        {
            args[i] = "args_"+ i;
            System.out.println(args[i]);
        }
    }
}
public class mainTest
{
    public static void main(String[] args)
    {
        main.main(new String[100]);
    }
}

3.main()方法也可以作为我们与控制台交互的方式（之前：Scanner）

public class main
{
    public static void main(String[] args) {
        for(int i=0;i<args.length;i++)
        {
            args[i] = "args_"+ args[i];
            System.out.println(args[i]);
        }
    }
}

传入args参数的方法
在这里插入图片描述

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

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

静态代码块

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

非静态代码块

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

public class person
{
    public String name;
    public int age;
    public static String decs = "I am a person!";
    public person(int age,String name)
    {
        super();
        this.age = age;
        this.name = name;
    }
    
    static
    {
        System.out.println(decs+"static 1");
    }
    
    static
    {
        System.out.println(decs+"static 2");
    }
    
    {
        System.out.println(decs+" 1");
        System.out.println(this.name +" "+this.age);//null 0 
        //构造器的执行在非静态代码块之前
    }
    
    {
        System.out.println(decs+" 2");
        System.out.println(this.name +" "+this.age);//null 0 
        //构造器的执行在非静态代码块之前
        //由父及子，静态先行
    }
    
}
public class blockTest
{
    public static void main(String[] args) {
        person p1 = new person(11,"QWE");
        person p2 = new person(15,"ASD");
    }
}

对属性赋值的位置与顺序

对属性可以赋值的位置：
①默认构造器
②显式初始化
③构造器中初始化
④有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值
⑤在代码块中赋值
顺序：①——②/⑤——③——④

四、关键字：final

1.final可以用来修饰的结构：类、方法、变量

2.final用来修饰一个类：此类不能被其他类继承（eg.String类、System类、StringBuffer类）

3.final用来修饰方法：此方法不可被重写（eg.Object类中getClass()）
4.final用来修饰变量：此时的“变量”就成为一个常量
5.final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化

public class finalTest
{
    final int UP;
    final int DOWN;
    final int LEFT;
    final int RIGHT = 3;//显式初始化
    finalTest(int up,int down)//构造器初始化
    {
        this.UP = up;
        this.DOWN = down;
    }
    {					//代码块初始化
        LEFT = 2;
    }
}

6.final修饰局部变量：尤其用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参，就只能在方法体内使用此形参，但不能进行重新赋值。
7.static final 用来修饰属性：全局常量

练习题

在这里插入图片描述

题目二中o.i++是正确的，new Other（）是错误的
引用数据类型的常量保证指向同一个地址/对象即可

五、抽象类与抽象方法

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

abstract关键字使用

1.abstract：抽象的
2.abstract可以用来修饰的结构：类、方法
3.abstract修饰类：抽象类，此类不能实例化，但一定有构造器，便于子类实例化时调用，开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
4.abstract修饰方法：抽象方法，只有方法的声明，没有方法体
包含抽象方法的类，一定是抽象类。反之，抽象类中可以没有抽象方法。
若子类重写了父类中的所有的抽象方法后，此子类可实例化
若子类没有重写所有抽象方法，则此子类也是一个抽象类，需要用abstract修饰

public  abstract class animal
{
    int age;
    String name;
    int legs;
    public animal(int age,String name)
    {
        this.age = age;
        this.name = name;
    }
    public abstract void cry();
}
public class Cat extends animal
{
    @Override
    public void cry() {
        System.out.println("喵喵喵！");
    }
    public Cat(int age,String name)
    {
        super(age, name);
    }
}

应用举例

在这里插入图片描述

注意事项

1.abstract不能用来修饰私有方法（私有方法不可被继承、重写）
2.abstract不能用来修饰静态方法（静态方法不可被重写）
3.abstract不能用来修饰final方法

抽象类的匿名子类

public class abstractTest
{
    public static void main(String[] args)
    {
        new Cat().cry();//创建类的匿名对象
        show(new animal() {//创建匿名类的匿名对象
            @Override
            public void cry() {
                System.out.println("miao~");
            }
            public void walk(){
                System.out.println("walk with four legs");
            }
            public void eat(){
                System.out.println("eat fish.");
            }
        });

        //匿名类的非匿名对象
        animal cat = new animal(){
            @Override
            public void cry() {
                System.out.println("miao~");
            }
            public void walk(){
                System.out.println("walk with four legs");
            }
            public void eat(){
                System.out.println("eat fish.");
            }
        };
        show(cat);
    }
    public static void show(animal a1)
    {
        a1.cry();
        a1.walk();
        a1.eat();
    }
}

应用：模板方法设计模式

在这里插入图片描述

在这里插入图片描述

public abstract class Template
{
    public void spendTime()//计算某代码执行所需要花费的时间
    {
        long start = System.currentTimeMillis();
        this.code();//不确定的部分、易变的部分
        long end = System.currentTimeMillis();
        System.out.println("Spend "+(end - start) +"s");
    }
    public abstract void code();
}

public class SubTemplate extends Template
{
    public void code()
    {
        for(int i=2;i<=100;i++)
        {
            boolean f = true;
            for(int j=2;j<=Math.sqrt(i);j++)
            {
                if(i%j==0)
                {
                    f = false;
                    break;
                }
            }
            if(f) System.out.println(i);
        }
    }
}

public class TemplateTest
{
    public static void main(String[] args) {
        SubTemplate s1 = new SubTemplate();
        s1.spendTime();// 0s
    }
}

六、接口（interface）

Java8中接口的新特性

  1. 接口中定义的静态方法，只能通过接口来调用
  2. 通过实现类的对象，可以调用接口中的默认方法，若类重写了默认方法，则调用的是重写后的方法
  3. 如果子类继承的父类和实现的接口中声明了同名同参数的方法，且子类未重写此方法时，默认调用的是父类中的同名同参数的方法(类优先原则)
  4. 若实现类实现了多个接口，而这些接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错（接口冲突）

举例：有两个接口：孝顺的，痴情的，一个父类：Father，他们均有一个help()方法，当子类man继承父类，且implements两个接口时，此时听老爸的；当子类重写了help方法时，则按照自己的内心走，当子类只implement两个接口时，报错。

概述

在这里插入图片描述

举例

在这里插入图片描述

使用

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

JDK 7及以前：只能定义全局常量和抽象方法
全局常量：public static final的。书写时，可以省略不写
抽象方法：public abstract的

JDK 8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）

4.接口中不能定义构造器，意味着接口不可实例化
5.Java开发中，接口通过让类去实现（implements）的方式来使用，如果实现类覆盖了接口中的所有抽象方法，则此实现类可实例化。如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6.Java类可以实现多个接口，弥补了Java的单继承性的局限性

格式：class AA extends BB implements CC,DD,EE
{

}

7.接口与接口之间可以继承，而且可以多继承

格式：interface AA extends BB,CC
{

}

8.接口的具体使用，体现多态性
9.接口，实际上可以看做是一种规范

代码示例

interface USB
{
    public void start();
    public void stop();
}
public class FlashDisk implements USB
{

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

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }
}
public class Printer implements  USB
{
    @Override
    public void start() {
        System.out.println("开始打印文件！");
    }
    @Override
    public void stop()
    {
        System.out.println("打印结束！");
    }
}
public class Computer
{
    public void transferData(USB usb)
    {
        usb.start();
        System.out.println("传输内容....");
    }
    public void printPaper(USB usb)
    {
        if(usb instanceof Printer)
        {
            usb.start();
        }
        else System.out.println("错误：此USB设备不可用于打印");
    }
}
public class USBTest
{
    public static void main(String[] args) {
        Computer computer = new Computer();//创建了接口的非匿名实现类的非匿名对象
        FlashDisk flashDisk = new FlashDisk();
        Printer printer = new Printer();
        computer.transferData(flashDisk);//体现多态性
        //computer.printPaper(flashDisk);
        computer.printPaper(printer);//体现多态性
    }
}

匿名对象与匿名类的示例说明

Computer computer = new Computer();//接口的非匿名实现类的非匿名对象
--------------------------------------------------------------------
Computer.transperData(new flashDisk());//非匿名实现类的匿名对象
---------------------------------------------------------------------
computer.transferData(new USB() {//匿名实现类的匿名对象
            @Override
            public void start() {
                
            }

            @Override
            public void stop() {

            }
        });
----------------------------------------------------------------------------
USB printer = new USB() {
            @Override
            public void start() {
                
            }

            @Override
            public void stop() {

            }
        };
        computer.printPaper(printer);//匿名实现类的非匿名对象

面试题：抽象类和接口有哪些异同？

应用：代理模式（Proxy）

在这里插入图片描述

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

public 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();
    }
}

public class NetworkTest
{
    public static void main(String[] args) {
        Server server1 = new Server();
        ProxyServer proxyServer1 = new ProxyServer(server1);
        proxyServer1.browse();
    }
}
interface Network
{
    public void browse();
}

在这里插入图片描述

应用：工厂设计模式

在这里插入图片描述

JDK8中接口的使用

在这里插入图片描述

1.接口中定义的静态方法，只能通过接口来调用
2.通过实现类的对象，可以调用接口中的默认方法
3.如果实现类重写了接口中的默认方法，调用时，仍然执行的是重写后的方法
4.如果子类（实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法
5.如果实现类实现了多个接口，且这些接口中定义了同名同参数的默认方法，那么实现类没有重写此方法的情况下，报错--->接口冲突

代码示例：接口冲突的解决方式

interface Filial
{
    public default void help()
    {
        System.out.println("救老妈！");
    }
}

interface Spoony
{
    public default void help()
    {
        System.out.println("救媳妇！");
    }
}
public class Father
{
    public void help()
    {
        System.out.println("救你老妈！");
    }
}
public class Man extends Father implements Filial,Spoony
{
    @Override
    public void help()
    {
        System.out.println("我该怎么办呢？");
        Filial.super.help();//救老妈
        Spoony.super.help();//救老婆
        super.help();//如果不进行指明，默认继承父类的方法
    }
}

接口的课后练习

在这里插入图片描述

编译不通过，因为x是不明确的

在这里插入图片描述

Ball类中play()方法的重写可看做对两个接口的方法都进行了重写
重写方法中new Ball(“football”);写法是错误的，接口中定义的是常量，不能再重定向

七、类的内部成员之五：内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类
在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类

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

分类

成员内部类（static成员内部类和非static成员内部类）

一方面，作为外部类的成员：
调用外部类的结构
可以被static修饰
可以被4种不同的权限修饰

另一方面：作为一个类：
类内可以定义属性、方法、构造器等
可以被final继承，表示此类不能被继承
可以被abstract修饰

局部内部类（不谈修饰符）（方法内、代码块内、构造器内）
匿名内部类

代码示例

public class Person
{
   public static class Brain   //static成员内部类
   {

   }
   public class Food   //非static成员内部类
   {

   }

   {
       class emotion   //局部内部类
       {

       }
   }
   public Person() 
   {
       class soul     //局部内部类
       {

       }
   }
   public void speak()
   {
       class word  //局部内部类
       {
           
       }
   }
}

使用要点

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

public static void main(String[] args) {
        Person.Brain b1 = new Person.Brain();//创建静态的成员内部类的实例
        Person p1 = new Person();
        Person.Food food = p1.new Food();//创建非静态的成员内部类的实例
    }

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

	public class Food   //非static成员内部类
    {
        String name;
        public void display(String name)
        {
            System.out.println(name);//形参
            System.out.println(this.name);//内部类food的名字
            System.out.println(Person.this.name);//外部类person的名字
        }
    }

开发中局部内部类的使用

public class InnerClassTest
{
    
    public Comparable getComparable()   //返回一个实现了Comparable接口的类的对象
    {
        return new Comparable() //匿名实现类的匿名对象
    {
        @Override
        public int compareTo(Object o)
        {
            return 0;
        }
    };
    }
}

局部内部类的一个注意点

在局部内部类的方法中（比如：show）如果调用局部内部类所声明的方法（比如：method）中的局部变量，要求此局部变量声明为final的
JDK7及以前版本：要求显式声明为final
JDK8及以后版本：可以省略final的声明

posted @   安河桥北i  阅读(28)  评论(0)  编辑  收藏  举报
相关博文：
· Java 第五章 面向对象编程（中）
· Java 第四章 面向对象编程（上）
· 第6章：面向对象编程（下）
· 面向对象(下)
· Java入门 | 6_面向对象-下
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
点击右上角即可分享
微信分享提示