安安静静学JAVA(十六)

最新推荐文章于 2024-01-20 17:08:00 发布
最新推荐文章于 2024-01-20 17:08:00 发布
阅读量156 收藏
点赞数
分类专栏： 每天学习内容 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_xiaomo/article/details/108551267
版权

单例模式

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象

单例设计模式的作用：

  • 目的: 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
  • 解决的问题: 一个全局使用的类频繁地创建与销毁。
  • 什么时候使用: 当您想控制实例数目，节省系统资源的时候。

饥汉式

    1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。

  1. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。

  2. 定义一个静态方法返回这个唯一对象。

/**
 *
 * 单例设计模式 --- 饿汉式
 *
 *  能够在多线程环境下保证单例!   ->  实际开发可以使用
 *
 *  缺点: 不符合懒加载的原则
 */
public class Singleton {
    // 1. 私有构造方法, 不让别人创建对象
    private Singleton() {
    }

    // 2. 单例的类中创建对象
    // private
    // static:
    //  1. getInstance方法使用
    //  2. static随着类的加载而加载, 使用类加载器的特点, 保证这个对象只创建一次!!!
    // final: 防止本类修改
    private static final Singleton instance = new Singleton();

    // 3. 对外提供用于获取对象的方法
    // static : 别的类可以直接使用
    public static Singleton getInstance() {
        return instance;
    }
}

public class MyTest {
    public static void main(String[] args) {
        // 创建Singleton对象, 让Singleton是单例
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    Singleton s = Singleton.getInstance();
                    System.out.println(s);
                }
            }
        };

        for (int i = 0; i < 100; i++) {
            new Thread(r).start();
        }

    }
}

懒汉式

  • 懒汉单例设计模式就是调用getInstance()方法时实例才被创建，先不急着实例化出对象，等要用的时候才例化出对象。

普通实现

/**
 * 单例设计模式 --- 懒汉式
 *
 *  保证了懒加载的原则
 *
 *  缺点: 多线程环境下不能保证单例
 *
 *  实际开发过程中, 不能用!!!
 *
 */
public class Singleton {

    // 1. 私有构造方法
    private Singleton() {
    }

    // 2. 只做声明Singleton, 不创建
    private static Singleton instance; // 默认值是null

    // 3. 对外提供用于获取对象的方法
    public static Singleton getInstance()  {
        // 只有第一次执行getInstance方法的时候需要创建对象,
        // 后面再执行getInstance方法, 直接返回第一次创建的对象
        if (instance == null) {
            // 对象的创建
            instance = new Singleton();
        }
        // 代码执行到这里, 说明instance一定不为null  -> 直接返回
        return instance;
    }

}

public class MyTest {
    public static void main(String[] args) {
        // 创建Singleton对象, 让Singleton是单例
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    Singleton s = Singleton.getInstance();
                    System.out.println(s);
                }
            }
        };

         for (int i = 0; i < 100; i++) {
            new Thread(r).start();
         }

    }
}

同步方法实现

/**
 *
 *  单例设计模式  --- 懒汉式(同步方法)
 *
 *  懒加载, 多线程环境下没有问题   ->   实际开发可以使用!!!
 *
 *  缺点: 每次执行都要获取锁和释放锁! 浪费资源!
 *
 */
public class Singleton {
    // 1. 私有构造方法
    private Singleton() {
    }

    // 2. 只做声明Singleton, 不创建
    private static Singleton instance; // 默认值是null

    // 3. 对外提供用于获取对象的方法(同步方法)
    public synchronized static Singleton getInstance()  {
        // 只有第一次执行getInstance方法的时候需要创建对象,
        // 后面再执行getInstance方法, 直接返回第一次创建的对象
        if (instance == null) {
            // 对象的创建
            instance = new Singleton();
        }
        // 代码执行到这里, 说明instance一定不为null  -> 直接返回
        return instance;
    }
}

public class MyTest {
    public static void main(String[] args) {
        // 创建Singleton对象, 让Singleton是单例
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    Singleton s = Singleton.getInstance();
                    System.out.println(s);
                }
            }
        };

         for (int i = 0; i < 100; i++) {
            new Thread(r).start();
         }

    }
}

使用同步锁

public class Singleton {
    // 1. 私有构造方法
    private Singleton() {
    }

    // 2. 只做声明Singleton, 不创建
    private static Singleton instance; // 默认值是null


    /*
        如果这个方法写成同步方法, 无论什么时候, 执行getInstance方法都会获取锁和释放锁
        我们希望, 先不着急获取锁, 等会再获取

        现在的格式起到的效果:  在单线程的情况下, 保证只有第一次执行的时候, 获取锁创建对象
        而后面的每一次执行都不会获取锁和创建对象
     */
    // 3. 对外提供用于获取对象的方法(同步方法)
    public static Singleton getInstance()  {
        // 只有第一次执行getInstance方法的时候需要创建对象,
        // 后面再执行getInstance方法, 直接返回第一次创建的对象
        if (instance == null) {

            synchronized (Singleton.class) {
                // 对象的创建
                instance = new Singleton();
            }
        }
        // 代码执行到这里, 说明instance一定不为null  -> 直接返回
        return instance;
    }
}

public class MyTest {
    public static void main(String[] args) {
        // 创建Singleton对象, 让Singleton是单例
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    Singleton s = Singleton.getInstance();
                    System.out.println(s);
                }
            }
        };

         for (int i = 0; i < 100; i++) {
            new Thread(r).start();
         }

    }
}

双重检查

/**
 * 单例设计模式 --- 双重检查
 *
 * 优点 : 懒加载,  多线程保证只有一个对象,  不会每一次都获取锁和释放锁
 */
public class Singleton {
    // 1. 私有构造
    private Singleton() {
    }
    // 2. 声明引用, 不创建对象
    // volatile : 禁止指令重排序
    private static volatile Singleton instance;
    // 3. 对外提供用于获取对象的方法
    public static Singleton getInstance() {
        // 判断
        if (instance == null) { // 和下面的同步-> 减少获取锁的次数
            synchronized (Singleton.class) {
                if (instance == null) { // 保证单例!!!
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class MyTest {
    public static void main(String[] args) {
        // 创建Singleton对象, 让Singleton是单例
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    Singleton s = Singleton.getInstance();
                    System.out.println(s);
                }
            }
        };

         for (int i = 0; i < 100; i++) {
            new Thread(r).start();
         }

    }
}

多例模式

多例模式，是一种常用的软件设计模式。通过多例模式可以保证系统中，应用该模式的类有固定数量的实例。

实现步骤：

1.创建一个类, 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。

​2.在类中定义该类被创建的总数量

​3.在类中定义存放类实例的list集合

​4.在类中提供静态代码块,在静态代码块中创建类的实例

​5.提供获取类实例的静态方法

/*
    多例设计模式

        创建对象的时候, 只能创建固定个数个实例
 */
public class Multition {

    // 1. 私有构造
    private Multition() {
    }

    // 2. 创建变量 , 用来代表集合中对象的个数
    private static int count = 3;

    // 3. 创建集合
    private static ArrayList<Multition> list = new ArrayList<>();

    // 在静态代码块中, 创建n个对象, 放到集合中
    // 类加载的时候就执行, 只执行一次
    static {
        for (int i = 0; i < count; i++) {
            list.add(new Multition());
        }
    }

    // 对外提供用来获取对象的方法
    public static Multition getInstance() {
        // 创建随机数对象
        Random r = new Random();
        // 获取随机数(集合中的随机索引)
        int randomIndex = r.nextInt(list.size());
        // 获取这个索引对应的对象
        Multition instance = list.get(randomIndex);
        // 返回集合中的一个元素
        return instance;
    }
}

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

        for (int i = 0; i < 100; i++) {
            Multition m = Multition.getInstance();
            System.out.println(m);
        }

    }
}

枚举

不使用枚举存在的问题：可以给性别传入任意的字符串，导致性别是非法的数据，不安全。

枚举的作用：

一个方法接收的参数是固定范围之内的时候，那么即可使用枚举。

枚举的概念：

枚举是一种特殊类。枚举是有固定实例个数的类型，我们可以把枚举理解成有固定个数实例的多例模式。

定义枚举的格式

在这里插入图片描述

枚举的本质是一个类，所以枚举中还可以有成员变量，成员方法等在这里插入图片描述

在这里插入图片描述配合 swich 用法

// RED, YELLOW, GREEN
// 都是Light类的对象,
// 默认修饰符: public static final
public enum Light {
    RED, YELLOW, GREEN;
}

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

        // 指定灯是什么颜色
        Light l = Light.GREEN;

        switch (l) {
            case GREEN:
                System.out.println("绿灯行!~");
                break;
            case YELLOW:
                System.out.println("黄灯等!~");
                break;
            case RED:
                System.out.println("红灯停!~");
                break;
        }

    }
}

用枚举对成员变量， 进行描述


public enum Season {
    // 这几个都是Season类的对象
    SPRING("春天在哪里"), SUMMER("夏天悄悄过去"), AUTUMN("秋天不回来"), WINTER("冬天里的一把火");

    // 成员变量， 进行描述
    private String describe;

    // 构造方法给成员变量赋值
    Season(String describe) {
        this.describe = describe;
    }

    public String getDescribe() {
        return describe;
    }
}

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

        Season s = Season.AUTUMN;
        System.out.println(s.getDescribe());

    }
}

枚举实现单例模式

 /**
 * 枚举实现单例设计模式
 */
public enum Singleton {
    INSTANCE;
}

public class MyTest {
    public static void main(String[] args) {
        // 创建Singleton对象, 让Singleton是单例
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    Singleton s = Singleton.INSTANCE;
                    System.out.println(s.hashCode());
                }
            }
        };

         for (int i = 0; i < 100; i++) {
            new Thread(r).start();
         }

    }
}

枚举实现单例模式

  • 它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

普通工厂模式

工厂模式其实就是用来帮我们创建对象的

工厂模式的作用：

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。可以解决类与类之间耦合的问题.

注意：

作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

代码:

public class BenZ implements Car {
    @Override
    public void run() {
        System.out.println("买了一辆奔驰, 跑的太慢!!!");
    }
}

public class BMW implements Car {
    @Override
    public void run() {
        System.out.println("买了一辆宝马, 操作还可以!");
    }
}

public class Ferrari implements Car {
    @Override
    public void run() {
        System.out.println("买了一辆法拉利, 跑的贼快!!~");
    }
}

public class Porsche implements Car {
    @Override
    public void run() {
        System.out.println("买了一辆破二手车, 太贵!!!");
    }
}


public interface Car {
    void run();
}


public class CarFactory {

    // 对外提供用来创建对象的方法
    public Car createInstance(String brand) {
        if ("benz".equalsIgnoreCase(brand)) {
            return new BenZ();
        } else if ("bmw".equalsIgnoreCase(brand)){
            return new BMW();
        } else if ("porsche".equalsIgnoreCase(brand)){
            return new Porsche();
        } else if ("ferrari".equalsIgnoreCase(brand)){
            return new Ferrari();
        } else {
            return null;
        }
    }

}


public class MyTest {
    public static void main(String[] args) {
        // 创建工厂的对象
        CarFactory factory = new CarFactory();
        // 使用工厂提供的方法, 创建Car的对象
        BenZ benz = (BenZ) factory.createInstance("benz");
        benz.run();
        BMW bmw = (BMW) factory.createInstance("bmw");
        bmw.run();
        Car porsche = factory.createInstance("porsche");
        porsche.run();
        Car ferrari = factory.createInstance("ferrari");
        ferrari.run();
    }
}

方法引用

是什么：是对Lambda的简化

方法引用的前提：

不是所有的匿名内部类都可以改成Lambda

不是多有的lambda都可以改成方法引用!!!

Lambda表达式中的内容, 是已经定义好的.

-

格式：

在这里插入图片描述

适配器模式

public interface Monk {

    void seat();

    void speak();

    void eatVegetable();

    void dragTree();

    void eatMeat();

}


public abstract class MonkAdapter implements Monk {
    @Override
    public void seat() {
    }

    @Override
    public void speak() {
    }

    @Override
    public void eatVegetable() {
    }

    @Override
    public void dragTree() {
    }

    @Override
    public void eatMeat() {
    }
}

public class FlowerMonk extends MonkAdapter {

    @Override
    public void dragTree() {
        System.out.println("倒拔垂杨柳");
    }

    @Override
    public void eatMeat() {
        System.out.println("大口吃肉!~");
    }
}


public class OneRest extends MonkAdapter {
    @Override
    public void seat() {
        System.out.println("打坐");
    }

    @Override
    public void speak() {
        System.out.println("格级格级");
    }

    @Override
    public void eatVegetable() {
        System.out.println("吃素");
    }

}
s_xiaomo
关注
专栏目录
JAVA之建造者模式
zhangxing
03-06 1470
1.建造者模式简介 建造者模式又名创建者模式，是将一个复杂对象的构建过程与它的表示分离，从而使得相同的构建过程可以创建不同的表示；创建者模式隐藏了复杂对象的创建过程，它把复杂对象的构建加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。2.建造者模式的角色①建造者角色（Builder） 对复杂对象的创建过程加以抽象，通过一个抽象接口来规范复杂对象的各个组成部分的构...
Linux启动Tomcat日志报错无法执行二进制文件
qq_34585611的博客
02-26 3810
问题描述 学习项目部署过程中，在顺利安装了tomcat后，执行./startup.sh，显示tomcat已经执行成功，但是无法通过外部访问tomcat。 查看日志，发现无法执行Java这个文件 [root@localhost tomcat-10]# tail -f logs/catalina.out /usr/test/tomcat-10/bin/catalina.sh:行491: /opt/jdk/bin/java: 没有那个文件或目录 /usr/test/tomcat-10/bin/catal
JAVA设计模式之创建者模式
Stroller
08-08 3707
概述：      Builder模式 主要用于“构建一个复杂的对象”。把复杂对象的创建过程加以抽象，通过子类继承和重写方法，来得到具有复合属性的对象。       同时为了统一创建过程，把对象的创建操作统一封装到Director的方法中。       由于一个复杂对象的
Java设计模式之建造者模式（创建型模式）
xiaoxiaoxiao_Ming的博客
01-19 356
定义 建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式或者生成器模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的 优点 封装性好，构建和表示分离。 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。
java建造者模式
波波烤鸭的博客
02-24 2855
  在现实生活中如果我们需要制造一个比较复杂的东西，比如手机，台式电脑，或者汽车等。如果我们要制造一台电脑的话我们会先将电脑所需的各个部件买回来然后在组装起来成为一台电脑。这里电脑所需的各个组件比如显示器，CPU，硬盘等等都是由不同的厂商生产的，然后被我们不同的组合而成了不同的产品。这是现实生活中和建造者模式类似的场景，而在程序中也一样有些情况下我们需要创建比较复杂的对象，在这种场景下我们可以通过...
java设计模式之创建者模式
qq_53799708的博客
08-14 364
（1）工厂方法模式vs建造者模式工厂方法模式注重的是整体对象的创建方式，而建造者模式注重的是部件的构造过程，意在通过一步步地精确构造创建出一个相对复杂的对象。（2）抽象工厂模式vs建造者模式抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品，具有不同分类纬度的产品组合，采用抽象工厂模式则不需要关心构建过程，只关心产品由什么工厂生产即可。建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装配件而产生一个产品。
java swing 飞机大战
12-26
Java Swing 是Java GUI（图形用户界面）开发的一个关键库，它是Java AWT（抽象窗口工具包）的扩展，提供了更为丰富的组件和更现代的外观。在这个"Java Swing 飞机大战"项目中，开发者利用Swing构建了一个飞机战斗...
JavaSE_8【IDE开发工具Idea使用】
yanyu1994的博客
07-26 2234
IDEA 全称IntelliJ IDEA，是Java语言开发的集成环境，目前已经渐渐代替了Eclipse的使用。IntelliJ在业界被公认为最好的Java开发工具之一，因其功能强悍、设置人性化，而深受Java、大数据、移动端程序员的喜爱。本着"工欲善其事必先利其器"的精神，本套视频从IDEA的介绍、安装、设置入手，讲解IDEA中项目的创建、模板的使用、断点调试等。 说明：本文档所有截图针对IntelliJ IDEA 2019.2.3 x64版本。 一、IntelliJ IDEA 介绍 1、JetBrai
【畅通版】配置spark环境（含前期的虚拟机virtualbox、ubuntu系统、Hadoop布局、Java环境配置等）
SophiaSSS的博客
07-13 920
暨上一篇环境配置过程曲折，加上突然意识到25G的ubuntu系统不够干大事，自己的500G固态硬盘分了350出去当主系统盘之后，还有115G剩余，刚好可以把虚拟机和ubuntu全丢过去，又不会占用到原Windows系统盘的空间。于是重新装虚拟机和ubuntu系统，再在这基础上布局Hadoop、Java、spark等。 附上一篇帖：【曲折版】配置spark环境（含前期的虚拟机virtualbox、u...
Spark入门学习和调优
purisuit_knowledge的专栏
04-14 5664
Spark运行原理自我理解： （1）首先程序有RDD Objects分解为DAG有向无环图 （2）提交DAGScheduler，根据shuffer将DAG分解为一组taskset，即stages （3）Taskset提交TaskScheduler，每个taskset在分解为多个task，即一个task就是一个split分区 （4）T...
java创建者模式实例
04-12
用java实现创建者模式,实现UML类图，并且实现一个消息发送的实例
java设计模式——创建者模式——单例设计模式
weixin_46823825的博客
05-24 242
创建者模式——单例设计模式 单例模式概述： 单例模式是java中最简单的设计模式之一，这种类型的数据模式属于创建型模式，它提供了一种创建对象的最佳方法。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实力化该类的对象。 单例模式的结构 单例模式主要有以下角色： 单例类：只能创建一个实例的类。 访问类：用来使用单例类。 单例模式的实现 从总体上看，单例模式的实现方式可以分为饿汉式和懒汉式。饿汉式是指在类加载过程中就会
java 设计模式--创建者模式
Misszhoudandan的博客
06-21 881
ConcreteBuilder 创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。：将复杂对象的创建过程分解在不同的方法中，不同的创建过程组装成不同对象。具体建造者 ConcreteBuilder：实现Builder抽象接口，构建和装配各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。抽象建造者 Builder：相当于建筑蓝图，声明了创建 Product 对象的各个部件指定的抽象接口。：如果对象的构造的入参十分复杂时，构造对象需要转为链式写法时。
Java设计模式----创建者模式
m0_57098080的博客
04-15 745
Java中设计模式概述以及五种创建者模式
java设计模式_创建者模式
xyj_520的博客
08-30 344
创建者模式 1.概念：建造者模式也叫生成器模式，主要是是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。 2.结构图 1.抽象生成器（Builder） 对复杂对象的创建过程加以抽象，给出一个抽象接口，以规范产品对象的各个组成部分的建造...
Java设计模式之创建型：建造者模式
qq_43414012的博客
06-20 184
建造者模式将复杂产品的创建步骤分解在在不同的方法中，使得创建过程更加清晰，从而更精确控制复杂对象的产生过程；通过隔离复杂对象的构建与使用，也就是将产品的创建与产品本身分离开来，使得同样的构建过程可以创建不同的对象；并且每个具体建造者都相互独立，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。 但建造者模式的缺陷是要求创建的产品具有较多的共同点、组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式。同时如果产品的内部变化复杂，可能会导致需要定义很多
建造者模式(Java实现)
星的博客
10-02 3027
建造者模式概念 是创建型模式之一，使用多个简单的对象创建一个复杂的对象，用于将一个复杂的构建与其表示分离，使得同样的构建过程可以创建不同的表示，然后通过一个Builder类创建最终对象。 建造者模式解决的问题 建造者模式主要用于解决软件系统中复杂对象的创建问题。例如复杂对象的创建通过各个部分的子对象用一定的算法构成，在需求变化时复杂对象面临大的改变，不利于系统的稳定，使用建造者将各个部分的算法包装起来，需求变化只需要将算法的顺序以及组合方式改变即可。 建造者模式需要的模块 Builder:创建一个
Java设计模式创建者模式（1）--- 单例设计模式
shuai_h的博客
03-25 120
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
24种设计模式之创建者模式-Java版
最新发布
nuist_NJUPT的博客
01-20 1468
软件设计模式是前辈们代码设计经验的总结，可以反复使用。设计模式共分为3大类，创建者模式(6种)、结构型模式(7种)、行为型模式(11种)，一共24种设计模式，软件设计一般需要满足7大基本原则。下面通过5章的学习一起来看看设计模式的魅力吧。创建型模式(6种)：本质上就是将对象的创建与使用分离，就是描述怎样去创建对象。包括：单例、简单工厂、工厂方法、抽象工厂、原型、建造者 模式创建型模式的对比：工厂方法模式VS建造者模式工厂方法模式更注重对象的创建方式，建造者模式更注重部件的创建过程。
现代教育技术：慕课、云技术和教学改革
讲授法“落后”的理由之一：它让学生“被动静听”，学生只能安安静静地听，老师讲什么，就只能听什么，自己的想法表达不出来。这确实存在一定的问题。但这与其说是讲授这种方法存在问题，不如说是教师的讲授水平不高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值