精华内容
下载资源
问答
  • 20145230《Java程序设计》课程总结每周读书笔记链接汇总实验报告链接汇总代码托管团队项目课程收获与不足我感觉自己收获最大的是提高了自己自学的能力。每周老师都要求我们自己写博客,自己学习新的内容,这对于以前...

    20145230《Java程序设计》课程总结

    每周读书笔记链接汇总

    实验报告链接汇总

    代码托管

    团队项目

    课程收获与不足

    我感觉自己收获最大的是提高了自己自学的能力。每周老师都要求我们自己写博客,自己学习新的内容,这对于以前的我是从未想过的,我根本没有想过会以这种资助的方式来学习一门课程。虽然结果不尽如人意,自己对java还是有很多地方没有掌握。估计娄老师要的效果也正是我们学会怎样去学习,而不是单单学习java这一门语言这样简单吧。现在当我在遇到问题的时候,会主动去解决,而不是坐享其成,邓老师全部说出来。我回去查资料,去问同学,实在不会了才回去问老师。总之,学习这门课程让我的学习态度改变了不少。不足之处在于我还是没能太懂这门语言,代码的阅读及理解还是不够细致。我遇到一些问题的时候,还是很依赖网络这个渠道,自己的能力还是不够。管是书上的、实践的还是实验的代码,基本上只要能运行出来,大概知道是干什么的就跳过了,很少一行一行的细读。除了最后几周做的项目开发有认真去研究代码外,其余大多都没有认真仔细的去看。做实验之前,也没有进行很好的预习,以后应该将实验步骤中的代码阅读理解一下,有准备的做实验。

    给学弟学妹们的学习建议

    建议就是好好跟着娄老师的步伐走,一定要按要求完成娄老师的每一项任务,不要偷懒。学习java没有太多敲门,只要你认真敲代码,总会学到点东西的。学习没有捷径,要的就是我们持之以恒的做一件事,到最后总归会有收获的。遇到问题尽量先靠自己解决,如果实在弄不懂再去问别人。这样做一方面是为了锻炼自己的独立思考能力,这对于自己水平的提高尤为重要,另外就是每个人的时间都非常宝贵,如果你一味的去问别人最后可能会让人有点反感。娄老师一直在引导我们进行博客的互评,最关键的就是看看别人学习过程中遇到的问题,有些问题可能正好你也碰到过,看看别人是怎么解决的,可以互相交流一下心得,对于两个人之间都有提高。对于那些你没遇到过的问题,你也可以留意一下,为以后编写代码提供借鉴。

    问卷调查

    你觉得这门课老师应该继续做哪一件事情?

    继续坚持每堂课测试,继续坚持每周写博客。

    你觉得这门课老师应该停止做哪一件事情?

    停止无意义的加分,感觉有些加分内容很多人都可以混分。

    你觉得这门课老师应该开始做什么新的事情?

    可以上课的时候适当多家昂一些内容,因为很多东西自己学实在很懵。

    展开全文
  • 七大设计原则 1.开闭原则,开闭原则是总纲,我们做系统首先需要满足开闭原则。 软件实体应对扩展开放,而对修改关闭。 2.单一职责原则,用于控制类的粒度大小,就是我们重构时,将一个复杂的类拆分为多个类。尽...

    七大设计原则

    1.开闭原则,开闭原则是总纲,我们做系统首先需要满足开闭原则。
    软件实体应对扩展开放,而对修改关闭。
    2.单一职责原则,用于控制类的粒度大小,就是我们重构时,将一个复杂的类拆分为多个类。尽可能地将一个类职责单一化。
    3.接口隔离原则,使用多个专门的接口,而不使用单 一的总接口,即客户端不应该依赖那些它不需要的接口。这个是关于接口定义时的指导方针,可以对比类的单一职责原则。就是要求将复杂的接口,拆分为多个功能单一的接口。比如我们的java集合框架。
    4.依赖倒转原则,抽象不应该依赖于细节,细节应当依 赖于抽象。换言之,要针对接口编程,而不是针对实现编程。
    5.里氏代换原则,所有引用基类(父类)的地方必须能透 明地使用其子类的对象。
    原则4和5,在我们实际编码中对应的就是,定义抽象层(抽象类或接口),关联和依赖的时候,是依赖于抽象层,实际运行时,替换为真实的子类或实现类。
    6.迪米特法则,一个软件实体应当尽可能少地与其他实体发生相互作用,不要和陌生人说话。迪米特法则可降低系统的耦合度,使类与类之间保持松散的耦合关系。
    7.合成复用原则,尽量使用对象组合,而不是继承来达到复用的目的。 就是我们常规的,某个类中定义别的类作为成员变量,或者入参,或者局部变量,或者静态方法的调用。比如,我们常规的需要建立一个http连接,然后发送消息时。我们直接调用httpClient类中的建立连接,设置消息等操作。
    总结:开闭原则是总纲,是目的;单一职责要求类简单,接口隔离要求接口简单,依赖倒置要求面向接口编程,里氏替换要求面向抽象编程,不破坏继承结构,迪米特法则要求低耦合,合成复用要求少用继承多用依赖。
    核心的一句话:所有问题都可以通过新增一个中间层来得到解决,如果不行,那就再多加一个中间层。比如:我们的策略模式中,定义抽象接口(中间层),具体的算法类;或者适配器模式中,我们新增了适配器作为中间层。

    设计模式

    分类:
    创建型:一共五种,就是关于对象的“创建”
    简单工厂,抽象工厂,构建者模式,原型模式,单例模式
    结构型:一共七种
    适配器,装饰,代理,外观,桥接,组合,享元
    行为型:一共11种
    模板方法,策略,观察者,中介,状态,责任链,命令,访问者,解释器,备忘录,迭代器

    工厂模式的演进:
    简单工厂模式示例代码:

    public class SimpleFactory{
        public Object getBean(String name){
         if("cat".equals(name)){
          return new Cat();
         }else if("cow".equals(name)){
          return new Cow();
         }。。。。。。
        }
       }

    缺点:不符合开闭原则,不利于扩展;类功能太繁重,职责不单一。
    改进:1.spring使用反射,通过反射创建对象。
    2.套用上面说的核心的那句话,我们增加中间层(也就是我们下面的抽象类AnimalFactory)。常规的消除if…else…的手段,定义抽象的类或接口,然后每个分支对应一个具体的子类或实现类。
    方式二的演变就是我们的工厂方法设计模式(特点:
    工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例)。示例代码如下:

    public abstract class AnimalFactory{
        public abstract Object getBean();
    }
    public class catFactory extends  AnimalFactory {
        public Object getBean(){
          return new Cat();
        }
    }
    public class DogFactory extends  AnimalFactory {
        public Object getBean(){
          return new Dog();
        }
    }
    展开全文
  • Java开发个人总结

    2019-08-20 17:26:26
    从事Java开发也有一段时间了,总感觉最近做的一些工作重复性太高太单一,在此总结一下个人设计到的一些技术吧,争取在三年内有自己的思维体系,不求广,求精细化。 个人做了一个小分类,系统化的学习复习一下。 一...

    从事Java开发也有一段时间了,总感觉最近做的一些工作重复性太高太单一,在此总结一下个人设计到的一些技术吧,争取在三年内有自己的思维体系,不求广,求精细化。

    个人做了一个小分类,系统化的学习复习一下。

    一、工程类

          1、Maven私服

               1)私服搭建

               2)setting详解

               3)pom.xml详解

          2、Jenkins

               1)Jenkins的安装部署

               2)Jenkins的打包到发布,集成mavne,git完成自动化部署

          3、Git(svn由于使用比较少,就没在这里写)

               1)Git的安装使用

               2)常用命令及详解

    二、代码(源码类)

          1、设计模式

               1)创建型模式

               2)结构型模式

               3)行为型模式

               注:详细内容请参考访问:https://www.cnblogs.com/pony1223/p/7608955.html

          2、源码及组件

               1)AOP及IOC原理、特性、配置

               2)事务处理机制

               3)ORM底层实现及原理

               4)spring特性

          3、常用的Mybatis

               1)常用ssm框架的搭建

               2)xml配置文件详解

               3)SessionFactory详解

               4)动态代理及性能提升

               5)数据连接池,查询原理

               6)多数据源配置原理详解

          4、Netty

               1)通信原理详解

               2)缓冲区详解及原理

               3)编码与高性能设计

               4)常用操作及使用

    三、分布式(以zookeeper为例)

          1、dubbo+zookeeper分布式框架

               1)dubbo+zookeeper框架搭建

               2)zookeeper的高可用配置

               3)dubbo的高扩展及容错机制

               4)paxos算法解读

          2、Nginx方向代理

               1)nginx+tomcat服务搭建

               2)https配置

    四,、微服务

          1、SpringCloud

               1)Eureka注册中心

               2)Ribbon和Feign负载均衡

               3)Hystrix断路器

               4)Zuul路由网关

               5)Bus消息总线

               6)服务链路追踪

               7)高可用的分布配置中心

               8)高可用的服务配置中心

               9)断路器监控及断路器聚合监控

               注:详细内容请参考访问:https://blog.csdn.net/forezp/article/details/70148833

          2、SpringBoot(由于springcloud也是基于springboot的所以我总结到微服务了)

               1)常用注解

               2)核心配置详解

               3)实现原理

               4)数据存储,配置,缓存,日志记录等

               5)与dubbo+zookeeper整合做分布式服务实战

    五、高并发(多线程及性能调优)

          1、多线程实现方式

               1)线程的状态

               2)多线程实现方式详解

               3)线程池的使用及原理详解

          2、JVM相关

               1)JVM运行区

               2)JVM内存模型,内存分配,内存回收

               3)JVM垃圾回收机(GC)详解

          3、关系型数据库相关(以Mysql为例)

               1)索引使用,原理及优化详解

               2)sql语句优化详解

               3)存储过程

               4)INNODB引擎和MYISAM引擎

          4、服务相关(以Tomcat为例)

               1)tomcat参数学习及优化

               2)具体配置及优化

               3)整合Nginx做反向代理服务实战

    六、数据结构及算法类(正在学习,比较简陋)

          1、基础知识

          2、线性表

          3、栈和队列

          4、字符串和数组

          5、树和二叉树

          6、图形

          注:具体内容请参考:https://blog.csdn.net/csdn_aiyang/article/details/84837553

    小弟文采一般,写的不怎好,以上就是个人的一些总结和学习方向了,望与各位同行共同进步,欢迎大佬前来批评,以后还会在此发帖,发出一些学习中遇到的问题。

    展开全文
  • 打字训练测试软件 Java 课程设计 1 2020 年 4 月 19 日 程序设计实践 题目 打字训练测试软件 学校陕西工业学院 学院信息学院 班级信管 12-2 学号 13156619 姓名刘克豪 年 11 月 09 日 文档仅供参考 基础类 IO 流与...
  • 本文是通过阅读《Head First 设计模式》和相关博客(http://blog.csdn.net/zhangerqing)加上自己体会写成。 一、设计模式简介 ...这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结

    本文是通过阅读《Head First 设计模式》和相关博客(http://blog.csdn.net/zhangerqing)加上自己体会写成。

    一、设计模式简介

    设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

    设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题,每种模式在现实中都有相应的原理来与之对应,每种模式都描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是设计模式能被广泛应用的原因。

    二、OO设计六大原则

    1、开闭原则(Open Close Principle)

    开闭原则就是说对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。

    2、里氏代换原则(Liskov Substitution Principle)

    里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。 LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

    3、依赖倒转原则(Dependence Inversion Principle)

    这个是开闭原则的基础,具体内容:针对接口编程,依赖于抽象而不依赖于具体。

    4、接口隔离原则(Interface Segregation Principle)

    这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。还是一个降低类之间的耦合度的意思,从这儿我们看出,其实设计模式就是一个软件的设计思想,从大型软件架构出发,为了升级和维护方便。所以上文中多次出现:降低依赖,降低耦合。

    5、迪米特法则(最少知道原则)(Demeter Principle)

    为什么叫最少知道原则,就是说:一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。

    6、合成复用原则(Composite Reuse Principle)

    原则是尽量使用合成/聚合的方式,而不是使用继承。有助于你保持每个类的封装,并被集中在单个任务上。这样类和类继承层次会保持较小规模,并且不太可能增长为不可控制的庞然大物。因为继承的层次增多,造成最直接的后果就是当你调用这个类群中的一个类时,就必须要把他们全部加载到栈中!(后果可想而知。)

    三、设计模式分类

    总体来说设计模式分为三大类:

    创建型模式:工厂方法模式、抽象工厂模式、单例模式。

    结构型模式:适配器模式、装饰器模式、代理模式、外观模式、组合模式。

    行为型模式:策略模式、模板方法模式、观察者模式、命令模式、状态模式、迭代器模式。

    四、设计模式分析

    1.工厂方法模式

    工厂方法模式就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。

    举例如下:(举一个披萨商店的例子)

    首先,创建一个抽象的披萨商店的类或借口:

    public interface Pizza{
    
      public void createPizza();
    
    }

    其次,创建具体的不同口味披萨实现类:

    public class SweetPizza implements Pizza{
    
      public void createPizza(){
    
      ...       //具体实现  
    
    }
    } 
    
    
    public class  SaltyPizza implements Pizza{
    
      public void createPizza(){
    
      ...       //具体实现  
    
    }
    }

    最后建立工厂:

    public class PizzaFactory{
    
    public Pizza produce(String type) {
    if ("sweet".equals(type)) {
    return new SweetPizza();
    } else if ("salty".equals(type)) {
    return new SaltyPizza();
    } else {
    System.out.println("请输入正确的类型!");
    return null;
    }
    }
    }

    测试类:

    public class FactoryTest {
    
    public static void main(String[] args) {
    PizzaFactory factory = new PizzaFactory();
    Pizza pizza = factory.produce("sweet");
    Pizza pizza = factory.produce("salty");
    }
    }

    2、抽象工厂模式

    工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,有可能对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑,有一定的问题,如何解决?就用到抽象工厂模式,创建一个抽象工厂接口,一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。

    举例如下:

    首先,创建一个Pizza接口和PizzaFactory接口:

    public interface Pizza{
    
      public void createPizza();
    }
    
    
    public interface PizzaFactory{
    
      public void produce();
    }

    两个Pizza类:

    public class SweetPizza implements Pizza{
    
      public void createPizza(){
    
      ...       //具体实现  
    
    }
    } 
    
    
    public class  SaltyPizza implements Pizza{
    
      public void createPizza(){
    
      ...       //具体实现  
    
    }
    }

    两个工厂类:

    public class ChicagoPizzaFactory{
    
    public Pizza produce(String type) {
    ...           //具体实现
    }
    }
    
    public class BostonPizzaFactory{
    
    public Pizza produce(String type) {
    ...           //具体实现
    }
    }

    测试类:

    public class FactoryTest {
    
    public static void main(String[] args) {
    
                    PizzaFactory chicagoFactory = new ChicagoPizzaFactory();
    PizzaFactory bostonFactory = new BostonPizzaFactory();
    Pizza pizza = chicagofactory.produce("sweet");
    Pizza pizza = bostonfactory.produce("sweet");
    }

    3、单例模式

    单例模式确保一个类只有一个实例,并提供全局访问点。这样的模式有几个好处:

    1、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。

    2、省去了new操作符,降低了系统内存的使用频率,减轻GC(垃圾收集器)压力。

    3、有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。(比如一个军队出现了多个司令员同时指挥,肯定会乱成一团),所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。
    首先我们写一个简单的单例类:

    public class Singleton {
    
    /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */
    private static Singleton instance = null;
    
    /* 私有构造方法,防止被实例化 */
    private Singleton() {
    }
    
    /* 静态工程方法,创建实例 */
    public static Singleton getInstance() {
    if (instance == null) {
    instance = new Singleton();
    }
    return instance;
    }
    
    /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
    public Object readResolve() {
    return instance;
    }
    }

    这个类可以满足基本要求,但是,像这样毫无线程安全保护的类,如果我们把它放入多线程的环境下,肯定就会出现问题了,如何解决?我们首先会想到对getInstance方法加synchronized关键字,如下:

    public static synchronized Singleton getInstance() {
    if (instance == null) {
    instance = new Singleton();
    }
    return instance;
    }

    但是,你只有第一次执行方法时需要同步。换句话说,一旦设置好instance变量,就不再需要同步了。之后每次调用这个方法,同步都是一种累赘。所以,这个地方需要改进。我们改成下面这个:

    public static Singleton getInstance() {
    if (instance == null) {
    synchronized (instance) {
    if (instance == null) {
    instance = new Singleton();
    }
    }
    }
    return instance;
    }

    似乎解决了之前提到的问题,将synchronized关键字加在了内部,也就是说当调用的时候是不需要加锁的,只有在instance为null,并创建对象的时候才需要加锁,性能有一定的提升。但是,这样的情况,还是有可能有问题的。synchronized块不同于真正意义的原子性操作,执行时是可以中断的,通过锁实现了线程访问共享数据的串行化。DCL单例模式在多线程的环境下是不安全的,若线程t1恰好在instance引用获得内存地址,但是对象尚未构造完成时被中断,线程t2发现instance引用已经!=null,直接调用instance的方法和属性,将导致意想不到的错误(对象锁仍然属于线程t1)。(详情见:http://m.blog.csdn.net/niexianglin_csdn/article/details/47361003
    我们可以利用JVM的机制来优化代码:

    private  class SingletonFactory{         
            private static Singleton instance = new Singleton();         
        }         
        public static Singleton getInstance(){         
            return SingletonFactory.instance;         
        } 

    我们依赖JVM在加载这个类时马上创建此唯一的单件实例。JVM保证在任何线程访问instance静态变量之前,一定先创建此实例。这样我们暂时总结一个完美的单例模式:

    public class Singleton {
    
    /* 私有构造方法,防止被实例化 */
    private Singleton() {
    }
    
    /* 此处使用一个内部类来维护单例 */
    private static class SingletonFactory {
    private static Singleton instance = new Singleton();
    }
    
    /* 获取实例 */
    public static Singleton getInstance() {
    return SingletonFactory.instance;
    }
    
    /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
    public Object readResolve() {
    return getInstance();
    }
    }
    展开全文
  • java基础个人总结

    2017-06-14 16:48:59
    一、java的专业术语: 1、JDK:编写java程序的程序员使用的软件 ...2、JRE:运行java程序的用户使用的软件 ...3、SE:用于桌面或简单的服务器应用的java平台 ...4、EE:用于复杂的... (1)、 java是一种程序设计
  • 需要设计一个接口,为一系列实现类提供统一的方法,多个实现类实现该接口。 下面一个计算器例子代码: 首先统一接口 public interface Calculator { public int calculate(String exp); } 辅助类
  • 很经典的一个使用装饰模式的java类是java.io类 FileInputStream、StringBufferInputStream、ByteArrayInputStream类是可以被装饰者包起来的具体组件,还有少量类没有显示在这里,例如ObjectInputStream。而...
  • java设计模式可将其分为三种类型:创建型、结构型、行为型。 创建型有:  工厂模式(Factory)单例模式(singleton)Builder模式(生成器模式)原型模式(Prototype) 壹.工厂模式(Factory)(典型案例:制造商品...
  • 此文档是本人在学习java设计模式的时候,个人的一个总结,包含了其中关系的一些导向图。简单明了的诠释
  • Java个人总结

    2016-05-15 19:47:18
    总结Begin: 项目1:五子棋 五子棋这个项目,首先就是要设计你的窗体和面板,这些基础的就不说了,添加组件和监听方面也不做详细介绍,我只说说这个项目最让我感兴趣的几点: 第一点:画笔。画笔是用来实现画图的,...
  • 前面用3篇文章具体的分析了14种设计模式的定义、特点,并给出了例子和具体实现。设计模式中不光只有这14种,更详细划分的话还有许多设计模式我没有涉及到,想了解的其余设计模式可以去阅读博客...
  • java个人总结

    2014-08-28 15:24:53
    网络上、书店都提供了很多资料,很多方式都可以得到J2EE... 其实, 换一个角度来看,比如,学英语,一共有三个层面的东西,首先是词汇,然后是语法,再者是习惯用法(希望读者能够从程序设计的角度考虑问题,看看这两者
  • 1.统计本学期课程的主要内容java 结构化程序设计(控制语句,运算符,标识符,关键字 for do while等等)面向程序设计(继承性,多态性等等)数组,字符串,向量与哈希表(一维数组,String等等)异常处理,递归(异常处理...
  • java七大设计原则: 一.开闭原则(Open Close Principle)OCP原则 定义:一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。 作用:保证以前代码的准确性,使开发者更专注于新扩展的代码上 二.单一职责...
  • java的基本程序设计个人总结要点 这是个人看完java核心卷一书之后,罗列的一些比较重要的点子,希望共享给大家。 【数值类型】 1.从java7开始,加上前缀0b就可以写二进制数,例如:0b1001代表9,在java中,...
  • 本组课题/本人任务使用物理引擎JBox2D完成游戏关卡的各个物理状态模拟根据物理引擎设计Bird,Pig,Brick等游戏中出现的可运动刚体类建立JBox2d的工具类以实现本人对这次课设的看法与吐槽课设内容的脑洞是我在看完17级...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 776
精华内容 310
关键字:

java设计个人总结

java 订阅