精华内容
下载资源
问答
  • Java进阶教程之IO基础

    2020-09-04 05:18:23
    主要介绍了Java进阶教程之IO基础,这里只是对Java IO的基本介绍,包含读取和写入等操作,需要的朋友可以参考下
  • 主要介绍了Java进阶教程之异常处理,本文讲解了JAVA的异常处理机制、异常的类型、抛出异常、自定义异常等内容,需要的朋友可以参考下
  • Java进阶教程之String类

    2020-09-04 05:19:40
    主要介绍了Java进阶教程之String类,String类对象是不可变对象(immutable object),String类是唯一一个不需要new关键字来创建对象的类,需要的朋友可以参考下
  • Java进阶教程课堂模仿

    2012-11-07 13:33:03
    关于java的GUI编程的示例,java进阶教程课后习题
  • 主要介绍了Java进阶教程之运行时类型识别RTTI机制,在Java运行时,RTTI维护类的相关信息,比如多态(polymorphism)就是基于RTTI实现的,需要的朋友可以参考下
  • 利刃出鞘Tomcat核心原理解析_java进阶教程Tomcat核心原理解析 源码笔记 bilibili链接:https://www.bilibili.com/video/av67233983?p=2 黑马官网链接:http://yun.itheima.com/course/569.html
  • 翁恺老师 Java进阶教程 城堡游戏 修改后 标题#game import java.util.HashMap; import java.util.Scanner; public class Game { private Room currentRoom; private HashMap<String, Handler> handlers = ...

    翁恺老师 Java进阶教程 城堡游戏 修改后

    标题#game

    import java.util.HashMap;
    import java.util.Scanner;
    
    public class Game {
    	private Room currentRoom;
    	private HashMap<String, Handler> handlers = new HashMap<String, Handler>();
    	
    	public void printWelcome() {
    		System.out.println(" ");
    		System.out.println("欢迎!");
    		System.out.println(" ");
    		System.out.println("这是一个超级无聊的城堡游戏");
    		System.out.println(" ");
    		System.out.println("如果你需要帮助请输入:help");
    		System.out.println(" ");
    		System.out.println("那么现在开始吧!");
    		System.out.println(" ");
    		
    		System.out.println("你现在在"+currentRoom+" "+currentRoom.getExitsdes());
    		
    		System.out.println();
    		
    	}
    	
    	public void createRoom() {
    		Room castle,read,outside,bar,bedroom;
    		
    		//创建房间
    		
    		castle = new Room("大堂");
    		read = new Room("书房");
    		outside = new Room("城堡外");
    		bar = new Room("酒吧");
    		bedroom = new Room("卧室");
    		
    		//初始化出口  Room east, Room south,Room west,Room north
    		castle.setExit("south", outside);
    		castle.setExit("west", bedroom);
    		read.setExit("south",castle);
    		outside.setExit("east",bar);
    		outside.setExit("north", castle);
    		bedroom.setExit("east",castle);
    		
    //		castle.setExit(null, outside,bedroom,read);
    //		read.setExit(null, castle,null, null);
    //		bar.setExit(null, null, outside, null);
    //		outside.setExit(bar, null, null,castle );
    //		bedroom.setExit(castle, null, null, null);
    		
    		currentRoom = outside;
    	}
    	
    	
    	public void goRoom(String k ) {
    		Room nextRoom = currentRoom.getExit(k);
    		
    		if(nextRoom == null) {
    			System.out.println("那里没有门");
    		}
    		else 
    		{
    			currentRoom = nextRoom;
    			System.out.println("你现在在"+currentRoom+" "+currentRoom.getExitsdes());
    			System.out.println();
    		}
    	}
    	
    	public void game() {
    		handlers.put("go", new HandlerGo(this));
    		handlers.put("bye",new HandlerBye(this));
    		handlers.put("help",new HandlerHelp(this));
    		createRoom();
    	}
    	public void startgame() {
    	
    		Scanner in = new Scanner(System.in);
    		String command;
    		String[]  k ;
    		
    		while(true) {
    			command = in.nextLine();
    			k = command.split(" ");
    			Handler handler = handlers.get(k[0]);
    			if(handler != null) {
    				String value = " ";
    				if(k.length > 1) 
    					value = k[1];
    				  handler.doCmd(value);
    				if(handler.isBye()) {
    					break;
    				}
    			
    			}
    			
    //			if(k[0].equals("go")) {
    //				goRoom(k[1]);
    //			}
    //			else if(k[0].equals("bye")) {
    //				break;
    //			}
    //			else if(k[0].equals("help")) {
    //				getHelp();
    //			}
    		}
    		in.close();
    	}
    	
    	public void AnywhereDoor(String range) {
    		
    	}
    	
    	
    	
    	public static void main(String[] args) {
    		Game a = new Game();
    		a.game();
    		a.printWelcome();
    		a.startgame();
    		
    		
    		System.out.println("欢迎您下次光临!");
    		
    	}
    
    }
    
    

    #Room

    import java.util.HashMap;
    
    public class Room {
    	private String description;
    	HashMap<String,Room> h = new HashMap<String, Room>(); 
    
    	public Room(String description) {
    		this.description = description;
    	}
    	
    	public String getExitsdes() {
    		StringBuffer s = new StringBuffer("可以走的方向有:");
    		for (String dir : h.keySet()) {
    			s.append(dir+" ");
    		}
    		return s.toString();
    		
    	}
    	
    	public Room getExit(String k) {
    		
    		Room nextRoom = h.get(k);
    		
    		return nextRoom;
    	}
    
    	public static void main(String[] args) {
    
    	}
    	
    	public void setExit(String dir , Room room) {
    		h.put(dir, room);
    	}
    
    	@Override
    	public String toString() {
    		return description;
    	}
    	
    	
    
    }
    
    

    #Handler

    
    public class Handler {
    	protected  Game game;
    	public Handler(Game game) {
    		this.game = game;
    	}
    	
    	public void doCmd(String cmd) {}
    	
    	public boolean isBye() {
    		return false;
    	}
    	
    }
    	
    
    

    #HandlerGo

    
    public class HandlerGo extends Handler {
    	
    	
    	public HandlerGo(Game game) {
    		super(game);
    	}
    	
    	@Override
    	public void doCmd(String cmd) {
    		game.goRoom(cmd);
    	}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    	}
    
    }
    
    

    #HandlerBye

    在这里插入代码片
    public class HandlerBye extends Handler {
    	public HandlerBye(Game game) {
    		super(game);
    	}
    
    	@Override
    	public boolean isBye() {
    		return true;
    	}
    
    }
    
    

    #HandlerHelp

    
    public class HandlerHelp extends Handler {
    	
    
    	public HandlerHelp(Game game) {
    		super(game);
    	}
    
    	@Override
    	public void doCmd(String cmd) {
    		System.out.println("迷路了吗?可以输入:go  bye  help 如:go east");
    	}
    
    	
    }
    
    
    展开全文
  • Java进阶教程:使用Lombok提升开发效率 Lombok  Lombok是一种Java™实用工具,可用来帮助开发人员消除Java的冗长代码,尤其是对于简单的Java对象(POJO)。它通过注释实现这一目的。通过在开发环境中实现Lombok...

    Java进阶教程:使用Lombok提升开发效率

    Lombok

      Lombok是一种Java™实用工具,可用来帮助开发人员消除Java的冗长代码,尤其是对于简单的Java对象(POJO)。它通过注释实现这一目的。通过在开发环境中实现Lombok,开发人员可以节省构建诸如hashCode()和equals()这样的方法以及以往用来分类各种accessor和mutator的大量时间。

    Lombok安装

      下面是通过Maven进行安装的,也可以在官网下载Jar包。

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.16.12</version>
    </dependency>

    插件安装

      Lombok通过编译时根据注解插入一些相关代码,来实现其简化开发的目的。所以,在开发时,诸如Setter/Getter等都是无法进行代码提示的。IDEA推荐使用Lombok插件:

      

     

    示例

    @Val和@Var

      前者定义常量,后者定义局部变量,其类型可以自动推测,不需要明确指出。

        public static void varAndVal(var c){ //[X]不可用于形参
            val a = 10; //[√]定义一个常量,其类型可自动推测
            var b = 10; //[√]定义一个变量,其类型可自动推测
            a++;         //[X]常量无法被修改,此处报错!
            b++;         //[√]此处为Int类型变量,可以进行自增操作
            b = "String";//[X]仍然遵循强类型规则,不可修改类型
        }
    

     

    @Cleanup和@SneakyThrows

      使用Cleanup以确保在代码执行路径退出当前作用域之前自动清除给定资源

        @SneakyThrows
        public static void cleanUp(){
            @Cleanup OutputStreamWriter writer = new OutputStreamWriter(System.out);
            writer.write("Hello World");
        }
    

      如果我们反编译该代码,Lombok自动为我们做了资源清理以及异常抛出

    public static void cleanUp() {
            try {
                OutputStreamWriter writer = new OutputStreamWriter(System.out);
    
                try {
                    writer.write("Hello World");
                } finally {
                    if (Collections.singletonList(writer).get(0) != null) {
                        writer.close();
                    }
    
                }
    
            } catch (Throwable var5) {
                throw var5;
            }
        }
    

       同时我们还用了一个注解@SneakyThrows,他可以帮助我们抛出已检查的异常而开发时不需要在方法的throws子句中实际声明

     

    @Getter和@Setter

      解放双手,不用再写访问器了!

    class Hello{
        @Getter
        @Setter
        private int a;
    
        public static void main(String[] args) {
           Hello a = new Hello();
            a.setA(10); //Setter
            System.out.println(a.getA()); //Getter
        }
    }
    

      

    @NonNull

      给方法参数增加这个注解会自动在方法内执行前对该参数进行是否为空的校验,如果为空,则抛出NPE(NullPointerException)

        //不会打印10
        public static void nonNull(@NonNull HashSet a){
            System.out.println(10);
            System.out.println(a.size());
        }
    
        //打印10后才会抛出异常,所以方法可能错误执行一部分
        public static void notNull(HashSet a){
            System.out.println(10);
            System.out.println(a.size());
        }
    

      加上这个注解后,实际代码如下:

        public static int nonNull(@NonNull HashSet a) {
            if (a == null) {
                throw new NullPointerException("a");
            } else {
                System.out.println(10);
                System.out.println(a.size());
                return 10;
            }
        }
    

     

    @ToString

      为使用该注解的类生成一个toString方法,默认的toString格式为:ClassName(fieldName= fieleValue ,fieldName1=fieleValue)。

    @ToString(includeFieldNames = true,exclude = {"a"})
    class Hello{
        @Getter
        @Setter
        private int a =10;
        private double b =20.19;
        private String c = "hello";
    
        public static void main(String[] args) {
            Hello a = new Hello();
            System.out.println(a);
            //RESULT:Hello(b=20.19, c=hello)
        }
    }
    

      

    @EqualsAndHashCode

      为使用该注解的类自动生成equals和hashCode方法。

    @EqualsAndHashCode
    class Hello{
        private int a =10;
        private double b =20.19;
        private String c = "hello";
    }
    

      加注解很简单,但实际上Lombok帮我们重写了equals和hashCode方法,可见其equals是比较了字段的值以及是否为null而得出的。

        public boolean equals(Object o) {
            if (o == this) {
                return true;
            } else if (!(o instanceof Hello)) {
                return false;
            } else {
                Hello other = (Hello)o;
                if (!other.canEqual(this)) {
                    return false;
                } else if (this.getA() != other.getA()) {
                    return false;
                } else if (Double.compare(this.b, other.b) != 0) {
                    return false;
                } else {
                    Object this$c = this.c;
                    Object other$c = other.c;
                    if (this$c == null) {
                        if (other$c == null) {
                            return true;
                        }
                    } else if (this$c.equals(other$c)) {
                        return true;
                    }
    
                    return false;
                }
            }
        }
    
        protected boolean canEqual(Object other) {
            return other instanceof Hello;
        }
    
        public int hashCode() {
            int PRIME = true;
            int result = 1;
            int result = result * 59 + this.getA();
            long $b = Double.doubleToLongBits(this.b);
            result = result * 59 + (int)($b >>> 32 ^ $b);
            Object $c = this.c;
            result = result * 59 + ($c == null ? 43 : $c.hashCode());
            return result;
        }
    

     

    @NoArgsConstructor, @RequiredArgsConstructor, @AllArgsContructor

    • @NoArgsConstructor : 生成一个无参数的构造方法
    • @AllArgsContructor: 生成一个包含所有变量的构造方法
    • @RequiredArgsConstructor: 会生成一个包含常量和标识了NotNull的变量的构造方法。生成的构造方法是私有的private。

      对于RequiredArgsConstructor来说,它提供了一种新的构造思路,即通过静态方法,赋予其有意义的方法名,来构造对象。

        private Hello(@NonNull double b, @NonNull String c) {
            if (c == null) {
                throw new NullPointerException("c");
            } else {
                this.b = b;
                this.c = c;
            }
        }
    
        public static Hello buildByBAndC(@NonNull double b, @NonNull String c) {
            return new Hello(b, c);
        }
    

     

    @Data

      @Data注解作用比较全,其包含注解的集合@ToString@EqualsAndHashCode,所有字段的@Getter和所有非final字段的@Setter@RequiredArgsConstructor

     

    @Builder

      Builder注解可以快速实现构建者模式,即通过函数来赋值字段,以及构建最终对象

    @ToString
    @Builder
    class Hello{
        private int a;
        private double b;
        private String c;
    
        public static void main(String[] args) {
            Hello a = Hello.builder().a(11).b(12).c("hi").build();
            System.out.println(a);
            //RESULT:Hello(a=11, b=12.0, c=hi)
        }
    }
    

      

    @Synchronized

      多线程开发时,锁定this或你自己的类对象可能会产生不幸的副作用,因为不受你控制的其他代码也可以锁定这些对象,这可能会导致竞争条件和其他讨厌的线程相关错误。

      @Synchronized注解类似Java中的Synchronized 关键字,但是可以隐藏同步锁,Lombok会自动去创建对象锁。

        @Synchronized
        public static void  synchDemo1(){
            System.out.println("World");
        }
    

      它实际编译的代码如下

        private static final Object $LOCK = new Object[0];
    
        public static void synchDemo1() {
            synchronized($LOCK) {
                System.out.println("World");
            }
        }
    

     

    Lombok原理

      Lombok这款插件依靠可插件化的Java自定义注解处理API(JSR 269: Pluggable Annotation Processing API)来实现在Javac编译阶段利用“Annotation Processor”对自定义的注解进行预处理后生成真正在JVM上面执行的“Class文件”
      
      从上面的Lombok执行的流程图中可以看出,在Javac 解析成AST抽象语法树之后, Lombok 根据自己编写的注解处理器,动态地修改 AST,增加Lombok自定义注解所需要生成的代码,最终通过分析生成JVM可执行的字节码Class文件。使用Annotation Processing自定义注解是在编译阶段进行修改,而JDK的反射技术是在运行时动态修改,两者相比,反射虽然更加灵活一些但是带来的性能损耗更加大

    参考链接

     

    转载于:https://www.cnblogs.com/MrSaver/p/11423747.html

    展开全文
  • Java进阶教程(一)关键字

    千次阅读 2017-04-09 13:56:20
    Java进阶教程(一)关键字 synchronized:当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。 instanceof:在运行时指出对象是否是特定类的一个实例。 result = object ...

    Java进阶教程(一)

    关键字

    synchronized:当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。

    instanceof:在运行时指出对象是否是特定类的一个实例。
    result = object instanceof class

    strictfp:strict float point (精确浮点),保证平台移植之后,浮点运算结果是一致的。

    transient:如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。即用transient关键字标记的成员变量不参与序列化过程。

    assert:断言可以证明程序的正确性。
    assert expression1
    assert expression1: expression2
    expression1表示一个boolean表达式,expression2表示一个基本类型、表达式或者是一个Object,用于在失败时输出错误信息。
    在eclipse中,必须开启相关设置。具体在Window->Preferences->Java->Installed JREs,选择相关版本,点击edit,在Default VM arguments里面输入-ea。

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Demo {
    
        public static void main(String[] args) {
            People people = new People();
            try {
                //序列化
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("people.dat"));
                oos.writeObject(people);
                oos.close();
                //反序列化
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("people.dat"));
                people = (People) ois.readObject();
                ois.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            //线程
            MyRunner boy = new MyRunner(people, "GG", "boy");
            MyRunner girl = new MyRunner(people, "MM", "girl");
            Thread thread1 = new Thread(boy,"boy");
            Thread thread2 = new Thread(girl,"girl");
            thread1.start();
            thread2.start();
            //断言
            boolean isPeople = people instanceof People;
            assert !isPeople:"it's wrong";
        }
    
    }
    
    class People implements Serializable{
        private String name;
        private String sex;
        private transient String school = "FJNU";
    
        public synchronized void set(String name,String sex) {
            this.name = name;
            this.sex = sex;
        }
    
        public void print(){
            System.out.println("name="+name+",sex="+sex+",school="+school);
        }
    }
    
    class MyRunner implements Runnable{
    
        private People people;
        private String name;
        private String sex;
    
        public MyRunner(People people,String name,String sex) {
            this.people = people;
            this.name = name;
            this.sex = sex;
        }
    
        @Override
        public void run() {
            for(int i=0;i<10;i++){
                people.set(name, sex);
                people.print();
            }
        }
    
    }
    运行结果如下:
    Exception in thread “main” name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=GG,sex=boy,school=null
    name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=MM,sex=girl,school=null
    name=GG,sex=boy,school=null
    name=GG,sex=boy,school=null
    name=GG,sex=boy,school=null
    name=GG,sex=boy,school=null
    name=GG,sex=boy,school=null
    name=GG,sex=boy,school=null
    name=GG,sex=boy,school=null
    name=GG,sex=boy,school=null
    java.lang.AssertionError: it’s wrong at Demo.main(Demo.java:32)

    请读者思考如下问题,欢迎在评论中互动:
    如果People的set方法去掉synchronized关键字,结果会怎样?
    为什么school是null?
    展开全文
  • java进阶教程Tomcat核心原理解析

    千人学习 2019-09-10 10:00:57
    1、 课程简介 Tomcat 服务器是一个免费的开放源代码的Web 应用服务器,属于轻量级应用服务器,在中小型系统下被普遍使用,是目前javaEE开发使用的最主流的服务器之一 。 本课程作为Tomcat高级课程, 从Tomcat...
  • Java进阶教程(二)代码块 构造代码块:给所有的对象进行统一的初始化。对象一建立就运行并且优先于构造函数。静态代码块:随着类的加载而加载。只执行一次,用于给类进行初始化。 public class Demo { public ...

    Java进阶教程(二)

    代码块

    构造代码块:给所有的对象进行统一的初始化。对象一建立就运行并且优先于构造函数。

    静态代码块:随着类的加载而加载。只执行一次,用于给类进行初始化。

        public class Demo {
    
            public static void main(String[] args) {
                System.out.println("main函数……");
                System.out.println("新建对象1:");
                new People("Canva");
                System.out.println("新建对象2:");
                new People("Chen");
            }
    
        }
    
        class People{
            private String name;
            public static String city;
    
            //静态代码块
            static {
                System.out.println("静态代码块……");
                city = "Fuzhou";
            }
    
            //构造代码块
            {
                System.out.println("构造代码块……");
                name = "unknow";
            }
    
            //构造函数
            public People(String name) {
                System.out.println("构造函数……");
                this.name = name;
            }
        }

    运行结果如下:
    main函数……
    新建对象1:
    静态代码块……
    构造代码块……
    构造函数……
    新建对象2:
    构造代码块……
    构造函数……


    作业

    请读者思考如下问题,欢迎在评论中互动:
    主函数、构造函数、静态代码块和构造代码块执行的先后顺序是怎样的?

    展开全文
  • java进阶教程elastic stack从入门到实践

    千人学习 2019-09-06 10:46:21
    有一定的Java基础,并且要有一定的web开发基础。   3、课程亮点    系统的学习ElasticStack技术栈,掌握最先进的搜索、数据收集等技术。   l Elasticsearch   n 快速入门   n 核心详解   n 中文分词 ...
  • java进阶中,我将对java基础进行补充,并转向应用层面。大部分编程语言都能够处理字符串(string)。字符串是有序的字符集合,比如"hello world!"。在java中,字符串被存储为string类对象。调用字符串对象的方法,...
  • 与其他语言相比,Java的IO功能显得复杂。在其他语言中,许多IO功能(比如读取文件),是被封装好的,可以用一两行程序实现。在Java中,程序员往往需要多个层次的装饰(decoration),才能实现文件读取。相对的复杂性带来...
  • MQ 简介 消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流,并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型,它可以在... 更多教程点击关注,私信可免费领取视频教程以及文档笔记
  • 程序很难做到完美,不免有各种各样的异常。比如程序本身有bug,比如程序打印时打印机没有纸了,比如内存不足。为了解决这些异常,我们需要知道异常发生的原因。...面向对象语言,比如C++, Java, Python往往有...
  • Java中I/O操作主要是指使用java.io包下的内容,进行输入、输出操作。输入也叫做读取数据,输出也叫做作写出数据。 1.2 IO的分类 根据数据的流向分为:输入流和输出流。 输入流 :把数据从其他设备上读取到内存中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,110
精华内容 444
关键字:

java进阶教程

java 订阅