标签分类
当前位置:首页 > 程序设计电子书 > Java电子书网盘下载
Java语言程序设计:基础篇 Java语言程序设计:基础篇
码小辫

码小辫 提供上传

资源
29
粉丝
28
喜欢
223
评论
10

    Java语言程序设计:基础篇 PDF 超清第10版

    Java电子书
    • 发布时间:

    给大家带来的一篇关于Java相关的电子书资源,介绍了关于Java、程序设计方面的内容,本书是由机械工业出版社出版,格式为PDF,资源大小259 MB,Y.Daniel Liang编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:8.6,更多相关的学习资源可以参阅 程序设计电子书Java电子书、等栏目。

  • Java语言程序设计:基础篇 PDF 下载
  • 下载地址:https://pan.baidu.com/s/1hZDAgNnR22szn5C3TCXIcg
  • 分享码:ms26
  • 读者评价

    特意看了一段时间再来评论,讲解很详细,零基础可以自学看懂,虽然凭良心说翻译得很差……不过大概意思到了就得了

    内容讲的非常详细,堪比c++ primer plus,通俗易懂,值得购买!

    刚刚开始学习Java语言,看了几章节,感觉还不错,很适合像我这种零基础的的小白学习!

    ava语言的经典教材,多年来畅销不衰。本书全面整合了Java 8的特性,采用“基础优先,问题驱动”的教学方式,循序渐进地介绍了程序设计基础、解决问题的方法、面向对象程序设计、图形用户界面设计、异常处理、I/O和递归等内容 

    内容介绍

    本书是Java语言的经典教材,多年来畅销不衰。本书全面整合了Java 8的特性,采用“基础优先,问题驱动”的教学方式,循序渐进地介绍了程序设计基础、解决问题的方法、面向对象程序设计、图形用户界面设计、异常处理、I/O和递归等内容。此外,本书还全面且深入地覆盖了一些高级主题,包括算法和数据结构、多线程、网络、国际化、高级GUI等内容。

    本书中文版由《Java语言程序设计 基础篇》和《Java语言程序设计 进阶篇》组成。基础篇对应原书的第1~18章,进阶篇对应原书的第19~33章。为满足对Web设计有浓厚兴趣的同学,本版在配套网站上增加了第34~42章的内容,以提供更多的相关信息。

    本书特点

    基础篇介绍基础内容,进阶篇介绍高级内容,便于教师按需选择理想的教材。

    全面整合了Java 8的特性,对全书的内容进行了修订和更新,以反映Java程序设计的*技术发展。

    对面向对象程序设计进行了深入论述,包含GUI程序设计的基础和扩展。

    提供的大量示例中都包括了对问题求解的详细步骤,很多示例都是随着Java技术的引入不断地进行增强,这种循序渐进的讲解方式更易于学生学习。

    用JavaFX取代了Swing,极大地简化了GUI编程,比Swing更易于学习。

    更多有趣示例和练习,激发学生兴趣。在配套网站上还为教师提供了100多道的编程练习题。

    内容节选

    JAVA多线程并发下的单例模式应用

     

    单例模式应该是设计模式中比较简单的一个,也是非常常见的,但是在多线程并发的环境下使用却是不那么简单了,今天给大家分享一个我在开发过程中遇到的单例模式的应用。

    首先我们先来看一下单例模式的定义:

    一个类有且仅有一个实例,并且自行实例化向整个系统提供。
    单例模式的要素:
    1.私有的静态的实例对象
    2.私有的构造函数(保证在该类外部,无法通过new的方式来创建对象实例)
    3.公有的、静态的、访问该实例对象的方法

    单例模式分为懒汉形和饿汉式

    懒汉式:

    应用刚启动的时候,并不创建实例,当外部调用该类的实例或者该类实例方法的时候,才创建该类的实例。(时间换空间)

    优点:实例在被使用的时候才被创建,可以节省系统资源,体现了延迟加载的思想。

    缺点:由于系统刚启动时且未被外部调用时,实例没有创建;如果一时间有多个线程同时调用LazySingleton.getLazyInstance()方法很有可能会产生多个实例。

    例子:

    publicclassSingletonClass{
     //私有构造函数,保证类不能通过new创建
    privateSingletonClass(){}
    privatestaticSingletonClassinstance=null;
     publicstaticSingletonClassgetInstance(){
    if(instance==null){
     //创建本类对象
     instance=newSingletonClass();
    }
    returninstance;
    } 
    }
    

    饿汉式

    应用刚启动的时候,不管外部有没有调用该类的实例方法,该类的实例就已经创建好了。(空间换时间。)

    优点:写法简单,在多线程下也能保证单例实例的唯一性,不用同步,运行效率高。

    缺点:在外部没有使用到该类的时候,该类的实例就创建了,若该类实例的创建比较消耗系统资源,并且外部一直没有调用该实例,那么这部分的系统资源的消耗是没有意义的。

    例子:

    publicclassSingleton{
    //首先自己在内部定义自己的一个实例,只供内部调用
    privatestaticfinalSingletoninstance=newSingleton();
    //私有构造函数
     privateSingleton(){
    }
    //提供了静态方法,外部可以直接调用
    publicstaticSingletongetInstance(){
    returninstance;
    }
    }
    下面模拟单例模式在多线程下会出现的问题
    /**
    *懒汉式单例类
    */
    publicclassLazySingleton{
    //为了易于模拟多线程下,懒汉式出现的问题,我们在创建实例的构造函数里面使当前线程暂停了50毫秒
    privateLazySingleton(){
    try{
    Thread.sleep(50);
    }catch(InterruptedExceptione){
    e.printStackTrace();
    }
    System.out.println("生成LazySingleton实例一次!");
    }
    privatestaticLazySingletonlazyInstance=null;
    publicstaticLazySingletongetLazyInstance(){
    if(lazyInstance==null){
    lazyInstance=newLazySingleton();
    }
    returnlazyInstance;
    }
    }
    

    测试代码:我们在测试代码里面新建了10个线程,让这10个线程同时调用LazySingleton.getLazyInstance()方法

    publicclassSingletonTest{
    publicstaticvoidmain(String[]args){
     //创建十个线程调
    for(inti=0;i<10;i++){
    newThread(){
    @Override
    publicvoidrun(){
    LazySingleton.getLazyInstance();
    }
    }.start();
    }
    }
    }
    

    结果:

    生成LazySingleton实例一次!
    生成LazySingleton实例一次!
    生成LazySingleton实例一次!
    生成LazySingleton实例一次!
    生成LazySingleton实例一次!
    生成LazySingleton实例一次!
    生成LazySingleton实例一次!
    生成LazySingleton实例一次!
    生成LazySingleton实例一次!
    生成LazySingleton实例一次!

    可以看出单例模式懒汉式在多线程的并发下也会出现问题,

    分析一下:多个线程同时访问上面的懒汉式单例,现在有两个线程A和B同时访问LazySingleton.getLazyInstance()方法。
    假设A先得到CPU的时间切片,A执行到if(lazyInstance==null)时,由于lazyInstance之前并没有实例化,所以lazyInstance==null为true,在还没有执行实例创建的时候

    此时CPU将执行时间分给了线程B,线程B执行到if(lazyInstance==null)时,由于lazyInstance之前并没有实例化,所以lazyInstance==null为true,线程B继续往下执行实例的创建过程,线程B创建完实例之后,返回。

    此时CPU将时间切片分给线程A,线程A接着开始执行实例的创建,实例创建完之后便返回。由此看线程A和线程B分别创建了一个实例(存在2个实例了),这就导致了单例的失效。

    解决办法:我们可以在getLazyInstance方法上加上synchronized使其同步,但是这样一来,会降低整个访问的速度,而且每次都要判断。

    那么有没有更好的方式来实现呢?我们可以考虑使用"双重检查加锁"的方式来实现,就可以既实现线程安全,又能够使性能不受到很大的影响。我们看看具体解决代码

    publicclassLazySingleton{
    privateLazySingleton(){
    try{
    Thread.sleep(50);
    }catch(InterruptedExceptione){
    e.printStackTrace();
    }
    System.out.println("生成LazySingleton实例一次!");
    }
    privatestaticLazySingletonlazyInstance=null;
    publicstaticLazySingletongetLazyInstance(){
     //先检查实例是否存在,如果不存在才进入下面的同步块
    if(lazyInstance==null){
     //同步块,线程安全地创建实例
     synchronized(LazySingleton.class){
     //再次检查实例是否存在,如果不存在才真正地创建实例
     if(lazyInstance==null){
      lazyInstance=newLazySingleton();
      }
     }
    }
    returnlazyInstance;
    }
    }
    

    这样我们就可以在多线程并发下安全应用单例模式中的懒汉模式。这种方法在代码上可能就不怎么美观,我们可以优雅的使用一个内部类来维护单例类的实例,下面看看代码

    publicclassGracefulSingleton{
    privateGracefulSingleton(){
    System.out.println("创建GracefulSingleton实例一次!");
    }
    //类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例没有绑定关系,而且只有被调用到才会装载,从而实现了延迟加载
    privatestaticclassSingletonHoder{
        //静态初始化器,由JVM来保证线程安全
    privatestaticGracefulSingletoninstance=newGracefulSingleton();
    }
    publicstaticGracefulSingletongetInstance(){
    returnSingletonHoder.instance;
    }
    }

    说一下我在实际开发中的场景:为了程序的高效率使用多线程并发,然而是循环调用,可能导致创建线程数过多,考虑采用线程池管理,这时候创建线程池仍然是处于循环调用中,也可能导致多个线程池,这时候就考虑使用单例模式。

    源代码:

    publicclassThreadPoolFactoryUtil{
    privateExecutorServiceexecutorService;
     //在构造函数中创建线程池
    privateThreadPoolFactoryUtil(){
    //获取系统处理器个数,作为线程池数量
    intnThreads=Runtime.getRuntime().availableProcessors();
    executorService=Executors.newFixedThreadPool(nThreads);
    }
    //定义一个静态内部类,内部定义静态成员创建外部类实例
    privatestaticclassSingletonContainer{
    privatestaticThreadPoolFactoryUtilutil=newThreadPoolFactoryUtil();
    }
    //获取本类对象
    publicstaticThreadPoolFactoryUtilgetUtil(){
    returnSingletonContainer.util;
    }
    publicExecutorServicegetExecutorService(){
    returnexecutorService;
    }
    }

    涉及到一个静态内部类,我们看看静态内部类的特点:

    1、静态内部类无需依赖于外部类,它可以独立于外部对象而存在。
    2、静态内部类,多个外部类的对象可以共享同一个内部类的对象。
    3、使用静态内部类的好处是加强了代码的封装性以及提高了代码的可读性。
    4、普通内部类不能声明static的方法和变量,注意这里说的是变量,常量(也就是finalstatic修饰的属性)还是可以的,而静态内部类形似外部类,没有任何限制。可以直接被用外部类名+内部类名获得。

    目录

    • 第1章 计算机、程序和Java概述 1
    • 第2章 基本程序设计 28
    • 第3章 选择 64
    • 第4章 数学函数、字符和字符串 100
    • 第5章 循环 133
    • 第6章 方法 171
    • 第7章 一维数组 207
    • 第8章 多维数组 242
    • 第9章 对象和类 270
    • 第10章 面向对象思考 309
    • 第11章 继承和多态 347
    • 第12章 异常处理和文本I/O 384
    • 第13章 抽象类和接口 424
    • 第14章 JavaFX基础 459
    • 第15章 事件驱动编程和动画 504
    • 第16章 JavaFX UI组件和多媒体 542
    • 第17章 二进制 I/O 584
    • 第18章 递归 609

    上一篇:轻量级Java EE企业应用实战  下一篇:Head First Python

    展开 +

    收起 -

    码小辫二维码
     ←点击下载即可登录

    Java相关电子书
    学习笔记
    网友NO.693701

    java基于C/S模式实现聊天程序(服务器)

    上篇介绍了java基于C/S模式实现聊天程序的客户端写法,这一篇介绍服务器的写法。 服务器的功能是:接收来自客户端的消息,然后将消息转发给当前连接的所有用户。这里一个困扰我许久的地方是如何存储所有用户的地址(套接字),找了许久我找到了一种变长数组的数据结构Vector,用size()来获取长度,用add()来添加元素,这样就容易多了,解决了服务器最大的问题。 服务器我定义了一个启动服务器的按钮,通过此按钮可以启动服务器的监听线程,我把服务器的创建放在了监听线程中。 服务器主要由两个线程组成:监听和消息处理。 监听线程:建立服务器的套接字,接收来自客户端的连接,每当有客户端连接到服务器时,服务器都要把该客户端的套接字添加到变长数组socketsss中,并且要给每个用户都创建单独的线程。 消息处理线程:在输入流中读取来自客户端的UTF字符串,然后遍历Vector数组socketsss,将UTF字符串写入到对每一个用户的输出流中。 服务器的功能就是这些了,这样就能实现基本的聊天室功能了,感觉最难的地方就是消息转发了,不过最后找到了合适的方法也解决了。只有当自己动手去写了才会发现自己有什么地方的不足,比如,设置关闭按钮的响应时,在弹出的对话框中点什么都关闭,后来发现是……

    网友NO.911505

    java实现网上购物车程序

    用java代码写一个简单的网上购物车程序,供大家参考,具体内容如下 需求: 1、写一个商品类,有商品编号、商品名称、商品分类、商品单价属性。 2、写一个商品条目信息类,有商品和数量两个属性,有商品总价格方法。 3、写一个购物车类,有添加商品方法、查看订单信息,删除商品,修改商品,清空购物车,求购物车中所有商品总金额方法。4、写一个测试类,测试上述方法。 商品类: public class Product { private int productId;// 商品编号 private String productName;// 商品名称 private String category;// 商品分类 private double price;// 单价 public Product() {// 无参构造 super(); } public Product(int productId, String productName, String category, double price) { super(); this.productId = productId; this.productName = productName; this.category = category; this.price = price; } public String toString() { return "Product [productId=" + productId + ", productName=" + productName + ", category=" + category + ", price=" + price + "]"; } public int getProductId() { return productId; } public void setProductId(int productId) { this.productId = productId; } public String getProductName() { return productName; } public void setProductName(String productName) { this.productName = productName; } public String getCategory() { return category; } public void setCategory(String category) { this.category = category; } public double getPrice(……

    网友NO.632672

    Java实现表白小程序

    今天闲来无事,教大家一个哄妹子的小case。我们需要创建一个心形图案,按照心形图案的位置和长度,对所创建的字符串进行截断并在所需的位置上输出,最终能呈现在屏幕上满满的爱心。废话不多说,直接上源码看效果 ~ package ddd; import java.awt.*; import javax.swing.JFrame; public class Cardioid extends JFrame { //获取屏幕大小 private static final int WIDTH = 500; private static final int HEIGHT = 500; private static int WINDOW_WIDTH = Toolkit.getDefaultToolkit().getScreenSize().width; private static int WINDOW_HEIGHT = Toolkit.getDefaultToolkit().getScreenSize().height; public Cardioid(){ super("I love you");//设置窗口标题 this.setBackground(Color.BLACK); this.setLocation((WINDOW_WIDTH-WIDTH)/2,(WINDOW_HEIGHT-HEIGHT)/2);//设置窗口位置 this.setSize(WIDTH, HEIGHT);//设置窗口大小 this.setLayout(getLayout());//设置窗口布局 this.setVisible(true);//设置窗口可见 this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);//设置窗口默认关闭方式 } public void paint(Graphics g){ double x,y,r;//横纵坐标以及半径 Image image = this.createImage(WIDTH, HEIGHT); Graphics pic = image.getGraphics(); for (int i = -2; i 90; i++) { for (int j = -2; j 90; j++) { r=Math.PI/45+Math.PI/45*i*(1-Math.sin(Math.PI/45*j))*18; x=r*Math.cos(Math.PI/45*j)*Math.sin(Math.PI/45*i)+WIDTH/2; y=-r*Math.sin(Math.PI/45*j)+HEIGHT/3; pic.setColor(Color.MAGENTA); pic.fillOval((int)x, (int)y, 2, 2); ……

    网友NO.743798

    浅谈Java程序运行机制及错误分析

    JVM(Java虚拟机 )一种用于计算设备的规范,可用不同的方式(软件或硬件)加以实现。编译虚拟机的指令集与编译微处理器的指令集非常类似。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 Java虚拟机(JVM)是可运行Java代码的假想计算机。只要根据JVM规格描述将解释器移植到特定的计算机上,就能保证经过编译的任何Java代码能够在该系统上运行。 1.为什么要使用Java虚拟机 Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行,至少需要编 译成不同的目标代码。而引入Java语言虚拟机后,Java语言在不同平台上运行时不需要重新编译。Java语言使用模式Java虚拟机屏蔽了与具体平台 相关的信息,使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码(字节码),就可以在多种平台上不加修改地运行。Java虚拟机在执行字 节码时,把字节码解释成具体平台上的机器指令执行。 Java运行机制 Java程序的运行必须经过编写 、编译 、运行 三个步骤。 编写是指在Java开发环境中进行程序代码的输入,最终形成后缀名为.java的Java源文件。 编译是指使用Java编译器对源文件进行错误排查的过程,编译后将生成后缀名为.c……

    网友NO.46857
    网友NO.46857

    Java程序设计学习知识点总结
    Java语言简单,面向对象,分布式,解释性,健壮,安全与系统无关,可移植,高性能,多线程,动态语言。
    什么是框架
    可以认为是某种应用的半成品,就是一组组件用来完善自己的应用。
    简单地说就是使用别人准备好的组件,来完成自己的项目。
    什么是跨平台
    跨平台就是能在如何操作系统上运行。
    什么是JVM
    JVM是java虚拟机。
    什么是JRE
    JRE:JVM+类库。
    什么是JDK
    JDK是提供给Java开发人员使用的开发工具。

    Copyright 2018-2019 xz577.com 码农之家

    版权责任说明