精华内容
下载资源
问答
  • Go的采用并不总是那么强劲,但是在包含在Docker等备受瞩目的项目中之后,情况就发生... 根据解决方案架构师和已发表的作者Shiju Varghese的博客文章 ,如果继续发展,Go的采用将成为企业中的下一个Java。 我们与Sp...

    繁琐冗长

    Go的采用并不总是那么强劲,但是在将其纳入包括Docker在内的备受瞩目的项目之后,情况发生了变化。 Go已被《纽约时报》和BBC Worldwide使用,但Booking.com,Dropbox,SoundCloud等也已使用Go,并且这种趋势还在持续。 根据解决方案架构师和已发表的作者Shiju Varghese的博客文章 ,如果继续发展,Go的采用将成为企业中的下一个Java。

    我们与Splice的联合创始人兼CTO Matt Aimonetti进行了交谈,讨论了Go的好处,Go社区及其改进该编程语言所能采取的措施。

    JAXenter:嗨,马特! 在您的Medium帖子中,您提到Go适合每个人。 你是什​​么意思?

    马特·艾蒙内蒂(Matt Aimonetti): Go是一门新兴的热门语言,它的采用正在飞速发展。 但是,我开始注意到有人认为该语言是高级语言,因此不适合新手程序员。 新程序员被告知,他们应该首先学习一种“更轻松”的语言,然后再使用Go语言。 在我的文章中,我认为新开发人员可能实际上想从Go开始。 我还想确保社区之外的开发人员不会将Go社区视为只保留给大公司的顶尖计算机科学家和工程师使用的精英社区。 最后,我鼓励社区为新程序员创建更多文档,文章和书籍。

    JAXenter:您为什么押注Go?

    Matt Aimonetti:三年前我创办初创公司Splice时,我知道我们需要扎实的代码基础。 我不得不处理糟糕的早期启动代码很多次,以至于我希望公司在开始获得良好的吸引力时不得不处理大量的技术债务。 在评估Clojure,Scala和Go时,并发性和高性能至关重要,因此Ruby,Python和JavaScript淘汰了。 我专业地写过一些Clojure,但我知道它并不适合我(虽然我喜欢函数式编程的概念,但我似乎无法以允许我稍后重新读取/跟踪代码的方式来构造代码) 。 Scala非常吸引人,但是由于缺乏清晰的样式指导,缓慢的编译以及以这种灵活的语言组建一支团队似乎具有挑战性的事实,我选择退出。 Go可以使您的思维更加简单,编译非常快,部署非常简单,已经在非常大型的团队中进行了测试,并且社区非常支持(以及组织良好并且充满了经验丰富/聪明的人)。 我决定下注Go,因为这在当时似乎是最好的选择。 我很高兴自己做到了。

    Go给您的目的更少。

    JAXenter:有些人认为Go太复杂了。 您对此有何看法?

    马特·艾莫内蒂(Matt Aimonetti):我认为“复杂”一词已超载。 作为一种主流编程语言,Go可能是最简单的编程语言之一,语言规范很短,并且功能清单有限(有意使用)。 就是说,它确实包含了一些概念,例如您没有像JavaScript这样的语言所拥有的指针,通道和接口。 我向新程序员教授Go的经验是,指针不是问题。 因为Go不支持指针算术,所以只要他们了解按值传递与按引用传递之间的区别,他们就可以理解指针。 通道用于并发,启动时可以大大避免使用。 最后,接口不是很复杂,但是要花一些时间才能掌握。 但是,我确实同意您需要学习一些基本的编程概念,而Go的第一行可能会比浏览器中的JS第一行花费更多的时间。 不同之处在于,您在旅途中发现JS或Ruby的复杂性/局限性时会遇到意外。 Go仅有一些惊喜,一旦您获得了惊喜,一切都不会阻止您。 它为您带来的魔力更少,但这也意味着更高的可读性和更少的意外/错误。

    Go不是灵丹妙药,它可能不适合您或您的项目。

    JAXenter:Go可以帮助开发人员探索其他编程语言吗?

    Matt Aimonetti:我坚信Go是入门和扎实基础的好方法。 这个基础将帮助您学习其他语言,例如Java,C#,Ruby,Rust ...

    Go使用推断的类型,这意味着它比Java少一些冗长,但仍然可以教您类型如何工作以及它们为何有用。 同时,Go支持鸭子输入,面向对象和功能编程。 但是Go没有像Ruby这样的解释器,它不允许进行猴子补丁,并且在代码样式方面比Ruby更自以为是。 尽管Go支持面向对象的编程,但它不支持继承。 这很棒,因为一旦Gopher开始探索Java或C#,他们就可以学习更丰富的OO方法并更好地了解优点/缺点。 另一件事是,Go没有泛型(Go社区中一个非常热烈的话题),因此一旦您习惯了在没有泛型的情况下进行编码并且切换到支持它们的新语言,您将拥有良好的基础并且可以专注于这项新功能。 换句话说,Go减少了您的学习目的,因此您学习Go编码的一切都与学习另一种语言时获得的额外功能密切相关。

    JAXenter:开发人员为什么要尝试Go?

    马特·艾莫内蒂(Matt Aimonetti):哈哈,现在,我觉得您是要我向您的读者出售Go。 Go不是灵丹妙药,它可能不适合您或您的项目。 但是我认为开发人员应该很好奇,并尽可能尝试新的语言。 现有的开发人员可能对更简单的编码方法感兴趣,或者他们希望本机并发支持,更好的性能和较低的内存使用率。 Go尝试回答以下问题:“您能用更少的钱做更多的事情吗?” 而且似乎运作良好。 如果您好奇并想了解Go语言,我强烈建议您尝试一下官方的Go Tour,它是免费的,在线的,可让您领略该语言。

    非常感谢你!

    翻译自: https://jaxenter.com/go-way-less-verbose-than-java-interview-127999.html

    繁琐冗长

    展开全文
  • java语言的优缺点

    2020-07-22 14:40:08
    在众多编程语言中,java长期占据TIOBE编程语言排名的前面位置。尽管出现了很多新的编程语言,但是java的名声从未下降...java拥有很多让你坚持使用它的优点,让我们来具体的讨论下java语言的这些优点吧。 1.简单 ...

         在众多编程语言中,java长期占据TIOBE编程语言排名的前面位置。尽管出现了很多新的编程语言,但是java的名声从未下降过。大多数专家都不能否认java是最强、最有效的编程语言之一,并且在众多领域广泛应用。

          但是,事物均有两面性,java也不例外。下面就介绍下java的优缺点。

     

    • 优点

    java是一种面向对象的通用编程语言,可以在任何平台上创建程序和应用。java拥有很多让你坚持使用它的优点,让我们来具体的讨论下java语言的这些优点吧。

        1.简单

          java语法是简单明了的、易于编写、学习、维护、理解和代码是易于debug的。并且,java没有其他语言如:C/C++那么复杂,因为很多复杂的特性如:显示的指针概念、类存储、操作符重载等都已经从java中移除掉了。

         2.面向对象

            java是一种面向对象的语言,它能帮助我们增强代码的灵活性和可重用性。利用OOPs的概念我们可以在其他程序中很轻松的重用对象。它可以用过将数据和方法绑定到单个单元中同时阻止被外部世界访问以提高程序的安全性。

          3.安全

            java通过避免采用显示的指针以减少安全攻击和风险。因为,指针存储了另一个值得内存地址,而这个值可能导致内存被未经授权访问。而java的安全管理器可以为每一个应用定义存取规则。

           4.维护成本低

            java程序可独立于特定的硬件基础设施运行,即是可以在任何机器上运行(安装对应的JVM),这样可减少额外的维护成本。

            5.平台独立

            只要机器上安装了对应的java虚拟机(JVM),经过编译的字节码就可以在该机器上(任何系统)上运行,如下图所示:

     

         6.高级语言、可读性高

          java与C++一样,与人类语言具有相似性、可读性高,语法简单易于维护。

          7.可移植

          由于java语言的平台独立性决定了,java应用可以从一个平台移植到其他任何的平台上。

          8.内存自动回收

           java虚拟机(JVM)中内置于内存自动管理机制,当java程序中的对象不再使用时java虚拟机内存管理机制会自动触发并销毁对象回收内存,而不需要程序显示的做任何事情。

          9.支持多线程

           java是一种多线程语言,即是在同一时刻可以有多个线程在执行。多线程可以帮助我们最大化CPU的利用率。多线程共享相同的内存空间,提升应用的效率和性能。各个线程之间独立运行互不影响。

             10.稳定性

               java每次发布的版本都会增加一些新特性,让java变得更加的稳定。

              11.高效内存分配策略

                java将内存主要分为堆区域和栈区域两部分,任何时候只要声明了一个变量,JVM就会为变量自动分配内存空间(堆空间/栈空间)。

                12.分布式语言

                 java是一种分布式语言因为它提供了在多个计算机之间共享数据和程序的机制以便改善系统的性能和效率。java的远程方法调用(RMI)为分布式处理提供了支持。并且,java也支持Sokcet编程和CORBA技术以帮助我们在分布式环境中共享对象。

     

    • 缺点

                 1.运行速度相对较慢、性能相对较低

                 由于java程序编译成字节码后需要解释成机器码,在JVM解释的过程中需要额外的抽象动作以及消耗更多的内存,并且,在垃圾回收的过程中需要消耗额外的CPU时间,这就降低了运行速度和性能。这也是java比原生的底层语言C或C++运行速度慢及性能低的原因。

                  2.GUI外观及体验不佳

                  尽管java处理许多图形界面工具如:Swing,SWT,JavaFX,JSF等但是它们都不适合用于复杂的UI。

                  3.没有备份工具

                  4.占用更多的内存

                  因为java运行垃圾回收时会消耗更多的内存空间,影响系统的效率和性能。

                  5.代码不够简洁

                   Java代码是冗长的,即是有许多单词和许多长而复杂的句子,难以阅读和理解。

                

                

    展开全文
  • kotlin和java语言It has been several years since Kotlin came out, and it has been doing well. Since it was created specifically to replace Java, Kotlin has naturally been compared with Java in many ...

    kotlin和java语言

    It has been several years since Kotlin came out, and it has been doing well. Since it was created specifically to replace Java, Kotlin has naturally been compared with Java in many respects.

    自Kotlin问世以来已经有好几年了,而且一切都很好。 自从Kotlin专门为替代Java而创建以来,自然在很多方面都与Java进行了比较。

    To help you decide which of the two languages you should pick up, I will compare some of the main features of each language so you can choose the one you want to learn.

    为了帮助您确定应该选择两种语言中的哪一种,我将比较每种语言的一些主要功能,以便您可以选择想要学习的一种。

    These are the 8 points I'll discuss in this article:

    这些是我将在本文中讨论的8点:

    • Syntax

      句法
    • Lambda Expressions

      Lambda表达式
    • Null Handling

      空处理
    • Model Classes

      模型类
    • Global Variables

      全局变量
    • Concurrency

      并发
    • Extension Functions

      扩展功能
    • Community

      社区

    语法比较 (Syntax comparison)

    To start it all let's do some basic syntax comparison. Many of you who are reading this might already have some knowledge about Java and/or Kotlin, but I will give out a basic example below so we can compare them directly:

    首先,让我们做一些基本的语法比较。 许多正在阅读本文的人可能已经对Java和/或Kotlin有所了解,但是我将在下面给出一个基本示例,以便我们直接进行比较:

    Java (Java)

    public class HelloClass { 
    
    	public void FullName(String firstName, String lastName) {
        	String fullName = firstName + " " + lastName;
    		System.out.println("My name is : " + fullName); 
    	} 
        
        	public void Age() { 
    		int age = 21;
    		System.out.println("My age is : " + age); 
    	} 
    
    	public static void main(String args[]) { 
    		HelloClass hello = new HelloClass(); 
    		hello.FullName("John","Doe");
            hello.Age();
    	} 
    }

    Kotlin (Kotlin)

    class NameClass {
        fun FullName(firstName: String, lastName:String) {
            var fullName = "$firstName $lastName"
            println("My Name is : $fullName")
        }
    }
    
    fun Age() {
    	var age : Int
        age = 21
        println("My age is: $age")
    }
    
    fun main(args: Array<String>) {
        NameClass().FullName("John","Doe")
        Age()
    }

    The feel of the code isn't that different aside from some small syntax changes in the methods and classes.

    除了在方法和类中进行一些小的语法更改外,代码的感觉没有什么不同。

    But the real difference here is that Kotlin supports type inference where the variable type does not need to be declared. Also we don't need semicolons ( ; ) anymore.

    但是真正的区别在于Kotlin支持类型推断,不需要声明变量类型。 另外,我们不再需要分号( ; )。

    We can also note that Kotlin does not strictly enforce OOP like Java where everything must be contained inside a class. Take a look at fun Age and fun main in the example where it is not contained inside any class.

    我们还可以注意到Kotlin并不像Java那样严格执行OOP,因为Java必须将所有内容都包含在一个类中。 看一下示例中没有包含的fun Agefun main

    Kotlin also typically has fewer lines of codes, whereas Java adheres more to a traditional approach of making everything verbose.

    Kotlin通常还具有较少的代码行,而Java则更加遵循使一切变得冗长的传统方法。

    One advantage of Kotlin over Java is Kotlin's flexibility – it can choose to do everything in the traditional OOP approach or it can go a different way.

    Kotlin相对于Java的一个优势是Kotlin的灵活性–它可以选择以传统的OOP方法进行所有操作,也可以采用其他方法。

    Lambda表达式 (Lambda Expressions)

    If we are talking about Java and Kotlin, of course we have to talk about the famous lambda expression. Kotlin has native Lambda support (and always has), while lambda was first introduced in Java 8.

    如果我们要谈论Java和Kotlin,那么我们当然必须谈论著名的lambda表达式。 Kotlin具有本地Lambda支持(并且一直有),而Lambda最初是在Java 8中引入的。

    Let's see how they both look.

    让我们看看它们的外观。

    Java (Java)

    //syntaxes
    parameter -> expression
    (parameter1, parameter2) -> { code }
    
    //sample usage
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(5);
    numbers.add(9);
    numbers.forEach( (n) -> { System.out.println(n); } );

    Kotlin (Kotlin)

    //syntax
    { parameter1, parameter2 -> code }
    
    //sample usage
    max(strings, { a, b -> a.length < b.length })

    In Java, the parentheses are more lenient: if only one parameter exists, there is no need for parenthesis. But in Kotlin brackets are always required. Overall, however, there are not many differences aside from syntax.

    在Java中,括号更为宽松:如果仅存在一个参数,则无需括号。 但在Kotlin中,始终需要使用括号。 总体而言,除了语法外,没有太多区别。

    In my opinion, lambda functions won't be used much aside from using them as callback methods. Even though lambda functions have so many more uses, readability issues make it less desirable. They'll make your code shorter, but figuring out the code later will be much more difficult.

    我认为,除了将lambda函数用作回调方法外,它不会被大量使用。 即使lambda函数有更多用途,但可读性问题仍使它不太理想。 它们会使您的代码更短,但是以后弄清楚代码将更加困难。

    It's just a matter of preference, but I think it's helpful that Kotlin enforces the mandatory brackets to help with readability.

    这只是一个偏好问题,但是我认为Kotlin强制使用必需的括号来帮助提高可读性是有帮助的。

    空处理 (Null Handling)

    In an object oriented language, null type values have always been an issue. This issue comes in the form of a Null Pointer Exception (NPE) when you're trying to use the contents of a null value.

    在面向对象的语言中,空类型值始终是一个问题。 当您尝试使用空值的内容时,此问题以空指针异常(NPE)的形式出现。

    As NPEs have always been an issue, both Java and Kotlin have their own way of handling null objects, as I will show below.

    由于NPE一直是一个问题,因此Java和Kotlin都有其处理空对象的方式,这将在下面显示。

    Java (Java)

    Object object = objServ.getObject();
    
    //traditional approach of null checking
    if(object!=null){
        System.out.println(object.getValue());
    }
    
    //Optional was introduced in Java 8 to further help with null values
    
    //Optional nullable will allow null object
    Optional<Object> objectOptional = Optional.ofNullable(objServ.getObject());
    
    //Optional.of - throws NullPointerException if passed parameter is null
    Optional<Object> objectNotNull = Optional.of(anotherObj);
    
    if(objectOptional.isPresent()){
        Object object = objectOptional.get();
        System.out.println(object.getValue());
    }
    
    System.out.println(objectNotNull.getValue());

    Kotlin (Kotlin )

    //Kotlin uses null safety mechanism
    var a: String = "abc" // Regular initialization means non-null by default
    a = null // compilation error
    
    //allowing null only if it is set Nullable
    var b: String? = "abc" // can be set null
    b = null // ok
    print(b)

    For as long as I can remember, Java has been using traditional null checking which is prone to human error. Then Java 8 came out with optional classes which allow for more robust null checking, especially from the API/Server side.

    就我所知,Java一直在使用传统的null检查,这很容易发生人为错误。 然后,Java 8推出了可选类,这些类允许进行更健壮的null检查,尤其是从API / Server方面。

    Kotlin, on the other hand, provides null safety variables where the variable must be nullable if the value can be null.

    另一方面,Kotlin提供了空安全变量,如果该值可以为空,则该变量必须为空。

    I haven't really used optional class yet, but the mechanism and purpose seems pretty similar to Kotlin's null safety. Both help you identify which variable can be null and help you make sure the correct check is implemented.

    我还没有真正使用可选类,但是机制和目的似乎与Kotlin的null安全性非常相似。 既可以帮助您确定哪个变量可以为null,又可以确保执行正确的检查。

    Sometimes in code there might be just too many variables lying around and too many to check. But adding checking everywhere makes our code base ugly, and nobody likes that, right?  

    有时,在代码中可能存在太多变量并且需要检查的变量太多。 但是到处添加检查会使我们的代码基础很难看,没有人喜欢它,对吧?

    In my opinion, though, using Java's optional feels a bit messy because of the amount of code that needs to be added for the checks. Meanwhile in Kotlin, you can just add a small amount of code to do null checking for you.

    但是,在我看来,使用Java的可选方法会感到有些混乱,因为需要为检查添加大量的代码。 同时,在Kotlin中,您只需添加少量代码即可为您执行null检查。

    型号类别 (Model Class)

    Some people might also refer to this as the Entity class. Below you can see how both classes are used as model classes in each language.

    某些人也可能将此称为Entity类。 在下面,您可以看到两种类如何在每种语言中用作模型类。

    Java (Java)

    public class Student {
    
         private String name;
         private Integer age;
         
         // Default constructor
      	 public Student() { }
    
         public void setName(String name) {
             this.name = name;
         }
    
         public String getName() {
             return name;
         }
         
         public void setAge(Integer age) {
             this.age = age;
         }
    
         public Integer getAge() {
             return age;
         }
    }

    Kotlin (Kotlin)

    //Kotlin data class
    data class Student(var name: String = "", var age: Int = 0)
    
    //Usage
    var student: Student = Student("John Doe", 21)

    In Java, properties are declared as private, following the practice of encapsulation. When accessing these properties, Java uses Getters and Setters, along with the isEqual or toString methods when needed.

    在Java中,遵循封装实践,将属性声明为私有。 访问这些属性时,Java将在需要时使用Getter和Setter以及isEqual或toString方法。

    On the Kotlin side, data classes are introduced for the special purpose of model classes. Data classes allow properties to be directly accessed. They also provide several in-built utility methods such as equals(), toString() and copy().

    在Kotlin方面,出于模型类的特殊目的引入了数据类。 数据类允许直接访问属性。 它们还提供了几种内置实用程序方法,例如equals(),toString()和copy()。

    For me, data classes are one of the best things Kotlin offers. They aim to reduce the amount of the boilerplate code you need for regular model classes, and they do a really good job of that.

    对我来说,数据类是Kotlin提供的最好的东西之一。 它们的目的是减少常规模型类所需的样板代码量,并且它们确实做得很好。

    全局变量 (Global Variables)

    Sometimes your code might need a variable needs to be accessed everywhere in your code base. This is what global variables are used for. Kotlin and Java each have their own ways of handling this.

    有时,您的代码可能需要在代码库中的任何位置访问变量。 这就是全局变量的用途。 Kotlin和Java都有各自的处理方式。

    Java (Java)

    public class SomeClass {
    	public static int globalNumber = 10;
    }
    
    //can be called without initializing the class
    SomeClass.globalNumber;

    Kotlin (Kotlin)

    class SomeClass {
        companion object {
            val globalNumber = 10
        }
    }
    
    //called exactly the same like usual
    SomeClass.globalNumber

    Some of you might already be familiar with the static keyword here since it's also used in some other language like C++. It's initialized at the start of a program's execution, and is used by Java to provide global variables since it is not contained as an Object. This means it can be accessed anywhere without initializing the class as an object.

    你们中的某些人可能已经在这里熟悉static关键字,因为它也在其他一些语言(例如C ++)中使用。 它在程序执行开始时进行了初始化,并且由于不包含在Object中,因此Java用于提供全局变量。 这意味着无需将类初始化为对象就可以在任何地方访问它。

    Kotlin is using quite a different approach here: it removes the static keyword and replaces it with a companion object which is pretty similar to a singleton. It let's you implement fancy features such as extensions and interfacing.

    Kotlin在这里使用了完全不同的方法:它删除了static关键字,并将其替换为与单例非常相似的伴随对象 。 它使您可以实现扩展和接口等高级功能。

    The lack of the static keyword in Kotlin was actually quite surprising for me. You could argue that using the static keyword might not be a good practice because of its nature and because it's difficult to test. And sure, the Kotlin companion object can easily replace it.

    实际上,在Kotlin中缺少static关键字令我感到非常惊讶。 您可能会争辩说使用static关键字可能不是一个好的做法,因为它的性质和测试难度很大。 当然,Kotlin随行对象可以轻松替换它。

    Even then, using static for global variable should be simple enough. If we are careful with it and don't make it a habit of making every single thing global, we should be good.

    即使这样,将static用于全局变量也应该足够简单。 如果我们谨慎对待它,而不是让它成为使每件事都全球化的习惯,那我们应该很好。

    The companion object might also give us some flexibility with interfacing and such, but how often will we ever be interfacing singleton classes?

    伴随对象还可能使我们在接口等方面具有一定的灵活性,但是我们将多久进行一次单例类接口呢?

    I think static keywords help us keep things short and clean for global variables.

    我认为静态关键字有助于我们使全局变量简短明了。

    并发 (Concurrency)

    Nowadays, concurrency is a hot topic. Sometimes the ability of a programming language to run several jobs concurrently might help you decide if that will be your language of choice.

    如今,并发是一个热门话题。 有时,一种编程语言可以同时运行多个作业的能力可能会帮助您确定这是否是您选择的语言。

    Let's take a look at how both languages approach this.

    让我们看一下两种语言如何实现这一目标。

    Java (Java)

    // Java code for thread creation by extending 
    // the Thread class 
    class MultithreadingDemo extends Thread 
    { 
        public void run() 
        { 
            try
            { 
                // Displaying the thread that is running 
                System.out.println ("Thread " + 
                      Thread.currentThread().getId() + 
                      " is running"); 
      
            } 
            catch (Exception e) 
            { 
                // Throwing an exception 
                System.out.println ("Exception is caught"); 
            } 
        } 
    } 
      
    // Main Class 
    public class Multithread 
    { 
        public static void main(String[] args) 
        { 
            int n = 8; // Number of threads 
            for (int i=0; i<n; i++) 
            { 
                MultithreadingDemo object = new MultithreadingDemo(); 
                object.start(); 
            } 
        } 
    }

    Kotlin (Kotlin)

    for (i in 1..1000)
        GlobalScope.launch {
            println(i)
        }

    Java mostly uses threads to support concurrency. In Java, making a thread requires you to make a class that extends to the in-built Java thread class. The rest of its usage should be pretty straightforward.

    Java主要使用线程来支持并发。 在Java中,创建线程要求您创建一个扩展到内置Java线程类的类。 其余的用法应该非常简单。

    While threads are also available in Kotlin, you should instead use its coroutines. Coroutines are basically light-weight threads that excel in short non-blocking tasks.

    虽然Kotlin中也提供了线程,但是您应该改用它的协程 。 协程基本上是轻量级线程,在短时间的非阻塞任务中表现出色。

    Concurrency has always been a hard concept to grasp (and also, to test). Threading has been used for a long time and some people might already been comfortable with that.

    并发一直是一个很难理解(以及测试)的概念。 线程已经使用了很长时间,有些人可能已经对此感到满意。

    Coroutines have become more popular lately with languages like Kotlin and Go (Go similarly has goroutines). The concept differs slightly from traditional threads – coroutines are sequential while threads can work in parallel.

    协程最近在诸如Kotlin和Go之类的语言中变得更加流行(Go同样具有goroutines)。 该概念与传统线程略有不同- 协程是顺序的,而线程可以并行工作

    Trying out coroutines, though, should be pretty easy since Kotlin does a very good job explaining them in their docs.  And one bonus for Kotlin over Java is the amount of boilerplate code that can be removed in Kotlin.

    但是,尝试协程应该很容易,因为Kotlin在他们的文档中很好地解释了协程。 Kotlin优于Java的一个好处是可以在Kotlin中删除的样板代码数量。

    扩展功能 (Extension Functions)

    You might be wondering why I'm bringing these up since Java itself doesn't even have this feature.

    您可能想知道为什么我要提出这些建议,因为Java本身甚至没有此功能。

    But I can't help but mention it, because extension functions are a very useful feature that was introduced in Kotlin.

    但是我不得不提,因为扩展功能是Kotlin中引入的一项非常有用的功能。

    fun Int.plusOne(): Int {
    	return this + 1
    }
    
    fun main(args: Array<String>) {
        var number = 1
        var result = number.plusOne()
        println("Result is: $result")
    }

    They allow a class to have new functionality without extending it into the class or using any of the fancy Design Patterns.  It even lets you to add functionality to Kotlin variable classes.

    它们允许类具有新功能,而无需将其扩展到类中或使用任何奇特的设计模式。 它甚至允许您向Kotlin变量类添加功能。

    You can practically say goodbye to those lib method that need you to pass everything inside your parameters.

    实际上,您可以对那些需要在参数中传递所有内容的lib方法说再见。

    社区 (Community)

    Last but not least, let's talk about something non-technical. First, let's take a look at this survey showing top commonly used programming languages in 2020.

    最后但并非最不重要的一点,让我们谈谈非技术性的东西。 首先,让我们看一下这份调查,该调查显示了2020年最常用的编程语言。

    We can see that Java is one of the most commonly used languages. And while Kotlin is still rising a lot in popularity, the Java community still remains several times larger than Kotlin and it will probably not change anytime soon.

    我们可以看到Java是最常用的语言之一。 尽管Kotlin仍在流行,但Java社区的规模仍然是Kotlin的几倍,并且它可能不会很快改变。

    So what does that matter then? Actually it does matter, a lot. With the amount of people in the Java community, it's much easier to find references and get help when you need it, both on the Internet and in the real world.

    那那有什么关系呢? 实际上,这确实很重要。 由于Java社区中的人员众多,因此在Internet和现实世界中,在需要时可以更轻松地找到参考并获得帮助。

    Many companies are also still using Java as their base and it might not change anytime soon even with Kotlin's interoperability with Java. And usually, doing a migration just doesn't serve any business purpose unless the company has really really important reasons for it.

    许多公司仍以Java为基础,即使Kotlin与Java具有互操作性,它也可能不会很快改变。 通常,除非公司有确实非常重要的理由,否则进行迁移根本不会达到任何业务目的。

    结语 (Wrapping up)

    For those just scrolling for the summary, here's what we discussed:

    对于仅滚动查看摘要的人员,这是我们讨论的内容:

    • Syntax: the patterns don't differ that much aside from slight syntax differences, but Kotlin is more flexible in several aspects.

      语法:除了语法上的细微差异外,这些模式没有太大差异,但是Kotlin在多个方面都更加灵活。
    • Lambda Expressions: the syntax is almost the same, but Kotlin uses curly brackets to help readability.

      Lambda表达式:语法几乎相同,但Kotlin使用大括号来提高可读性。
    • Null Handling: Java uses a class to help with null handling while Kotlin uses in-built null safety variables.

      空处理:Java使用一个类来帮助进行空处理,而Kotlin使用内置的空安全变量。
    • Model Classes: Java uses classes with private variables and setter / getter while Kotlin supports it with data classes.

      模型类:Java使用带有私有变量和setter / getter的类,而Kotlin通过数据类支持它。
    • Global Variables: Java uses the static keyword while Kotlin uses something akin to sub-classes.

      全局变量:Java使用static关键字,而Kotlin使用类似于子类的东西。
    • Concurrency: Java uses multi-threading whereas Kotlin uses coroutines (which are generally lighter).

      并发性:Java使用多线程,而Kotlin使用协程(通常比较轻)。
    • Extension Functions: a new feature introduced by Kotlin to easily give functionality into classes without extending it.

      扩展功能:Kotlin引入的一项新功能,可以在不扩展功能的情况下轻松地将其赋予类。
    • Community: Java still reigns supreme in the community aspect which makes it easier to learn and get help.

      社区:Java在社区方面仍然占据主导地位,这使得学习和获得帮助变得更加容易。

    There are many more features we could compare between Java and Kotlin. But what I've discussed here are, in my opinion, some of the most important.

    我们可以在Java和Kotlin之间进行比较的更多功能。 但是,我认为这里讨论的是一些最重要的内容。

    I think Kotlin is well worth picking up at the moment. From the development side it helps you remove long boilerplate code and keep everything clean and short. If you are already a Java programmer, learning Kotlin shouldn't be too hard and it's okay to take your time at it.

    我认为Kotlin目前非常值得一游。 从开发的角度来看,它可以帮助您删除冗长的样板代码,并使所有内容保持简洁。 如果您已经是Java程序员,那么学习Kotlin也不应该太困难,可以花些时间在上面。

    Thanks for reading! I hope that this article will help you decide which programming language you should pick, Java or Kotlin. And for anything that I'm missing, feel free to leave feedback for me as it will be very much appreciated.

    谢谢阅读! 我希望本文将帮助您确定应该选择哪种编程语言,Java还是Kotlin。 对于我所缺少的任何内容,请随时给我留下反馈,我们将不胜感激。

    翻译自: https://www.freecodecamp.org/news/kotlin-vs-java-which-language-to-learn-in-2020/

    kotlin和java语言

    展开全文
  • JavaBuilder项目是使用Java语言的Java项目管理和构建工具。 该工具与其他工具(例如Ant,Maven,Ivy,Gradle等)之间的主要区别在于,该构建工具使您可以直接在Java中工作。 由于您正在构建Java项目,因此可以安全...
  • 我的意思是,每个人现在都在诅咒它,预言Java会因为它的冗长而死,但是这样的人还能做得更好吗? 我对此表示怀疑。 只需考虑一下Java在企业中的渗透力即可.... Verbosity增强了可读性,这是企业中人们随处可见移动...

    怪癖有哪些

    在设计Java时,Sun的男孩们确实做了一件了不起的事情。 我的意思是,每个人现在都在诅咒它,预言Java会因为它的冗长而死,但是这样的人还能做得更好吗? 我对此表示怀疑。 只需考虑一下Java在企业中的渗透力即可.... Verbosity增强了可读性,这是企业中人们随处可见移动的好功能。

    但是,我偶然发现了一个令人困扰的怪癖。 大多数Java的细节都在编译时执行,并在运行时删除。 如果没有错误得到编译,则没有理由在运行时进行检查。 我发现的故障可以很好地编译,但在运行时会引发异常。

    考虑以下代码:

    Object[]objects=newString[1];
    objects[0]=newInteger(5);

    它编译起来很好,但是如果执行它,您将面临一个奇怪的java.lang.ArrayStoreException ......哪个语句错了? 显然是第一个。 如何将字符串数组视为对象数组?

    现在,我不太喜欢泛型及其在Java 5中复杂的实现方式,但是使用它们不可能实现这种特殊的怪癖。 以下两个摘要均无法编译:

    // Type mismatch: cannot convert from ArrayList<String> to List<Object>
    List<Object>list=newArrayList<String>();
    
    List<?extendsObject>list=newArrayList<String>();
    // The method add(capture#1-of ? extends Object) in the type
    //  List<capture#1-of ? extends Object> is not applicable for the arguments (Integer)
    list.add(newInteger(3));

    对于那些对理论感兴趣的人,这种将String数组视为Object数组的行为称为协方差。 说起来很有趣,但是Java 5泛型实际上是对数组的改进,而协方差是关注的!

    请注意,Scala使数组在编译时不变,因此可以正确处理该问题:

    // type mismatch;  found   : Array[String]  required: Array[java.lang.Object]
    vararray:Array[Object]=newArray[String](0)

    翻译自: https://blog.frankel.ch/a-java-language-quirk/

    怪癖有哪些

    展开全文
  • 这里还是以宠物猫为例,(不是为了水文章,因为可能全部放在一起的话,一是自己不好查找知识点,另外还有就是放在一篇blog中显得过于冗长) 在HashSet中存储了宠物猫的信息 查找需要进行查询操作的宠物猫信息 ...
  • Java语言的接口与类型安全接口是实现构件可插入性的关键,可插入构件的关键在于存在一个公用的接口,以及每个构件实现了这个接口。 什么是接口? Java中的接口是一系列方法的声明,是一些方法特征的集合,一个接口...
  • 洛谷P1143题题解,Java语言描述
  • java语言程序设计-基础篇

    万次阅读 2012-08-16 08:00:24
    第1章,计算机、程序和Java概述 1,java背景 特点: 一次编译,到处运行(Write Once, Run Anywhere.)。原理: Java源程序经编译后生成.class字节码文件,.class文件由Java虚拟机(JVM)解释执行。不同的操作系统...
  • 大一上学期学习 C语言 为下学期 的Java学习打下了基础。但是由于 新冠疫情 影响,目前在家自学,干扰挺大的,不说 家里琐碎事情,单说自己吧,发现自己 学习浮于表面,没有半点的深入和投入。这样的状态 很是反感,...
  • Java语言入门教程(二):Java类的包

    千次阅读 2009-06-04 17:38:00
    Java应用是由若干个类组成的。但是从逻辑上考虑,这些类解决的问题都是不同的。比如某些类解决了数据库访问问题,某些类解决了安全控制问题…就如同我们计算机硬盘上的文档,我们不会把它们都杂乱无章的放在某个硬盘...
  • Java语言 随机点名程序

    千次阅读 2020-12-04 11:49:38
    public int nextInt(int n) (5)“随机点名器”明确分为3个功能,如果将多个独立功能的代码写在一起,则代码冗长,可读性差,可以针对不同的功能将其封装到不同的方法中,将完整独立的功能分离出来,在main()...
  •  Android之java需掌握的30个基本概念  1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有...
  • JAVA语言常用英语

    千次阅读 2013-06-25 20:15:17
    这是因为计算机软件技术更新的速度越来越快,而这些技术大多来源于英语国家,我们在引进这些技术时往往受到语言障碍的制约,严重影响到对新技术的理解和消化。首先编程本身就依赖于英语,虽然现在技术的发展,可以...
  • jOOR,java joor中的joor-fluent反射是一个非常简单的fluent api,它以更直观的方式提供对java类结构的...jdk的反射api很难使用,而且冗长。其他语言有更简单的结构来在运行时访问类型元信息。让我们改进Java反射。.zip
  • 它是java.lang.reflect包的简单包装。 jOOR的名称受到jOOQ的启发,jOOQ是一种用于SQL构建和执行的流利的API。 依存关系 没有任何! 下载 适用于Java 9+ < groupId>org.jooq < artifactId>joor < version>...
  • 如果你还在大量使用if else,当然,界面表现层除外,即使你使用Java/C#这样完全面向对象的语言,也只能说明你的思维停留在传统的面向过程语言上。传统思维习惯分析 为什么会业务逻辑层使用if else,其实使用者的...
  • 简介: 尽管一些建议的语言功能可以解决遇到的某个问题,但其中大部分功能的存在都有现实环境中的根源,在这些环境中,现有功能无法使...每个 Java™ 开发人员可能都有一些关于如何改进 Java 语言的想法。在本系列
  • 转载▼ 结构 javac [ options ] [ sourcefiles ] [ @files ] 参数可按任意次序排列。 ...一个或多个要编译的源文件(例如 MyClass.java)。...javac 工具读取用 Java 编程语言编写
  • 结构javac [ options ] [ sourcefiles ] [ @files ]参数可按任意次序排列。options 命令行选项。 sourcefiles 一个或多个要编译的源文件(例如 MyClass.java)。... 说明javac 工具读取用 Java 编程语言编写的类和接
  • [b]第1章 引论[/b] 递归的四条基本法则 1. 基准情况。必须总要有某些基准情况,它无需递归就能解出。 2. 不断推进。对于那些需要递归求解的情况,每一次递归调用都必需要使状况朝向一...Java泛型 class MyClass...
  • PHP语言教父Gutmans炮轰Java

    千次阅读 2008-04-15 13:30:00
    PHP主要语言开发者之一、Zend公司的创始人之一Andi Gutmans最近在blog中直言不讳地批评了Java语言。他指出,目前Java厂商试图在JVM上提供动态语言实现的路子根本不对,应该全面拥抱标准的动态语言。由于Gutmans的...
  • 与90年代中期(预模板)的C ++相比,Java是一种完全令人惊奇的语言。 JVM是所有计算机语言的最佳运行时。 漫长的奇异之旅 从2002年开始,我开始做C#。 然后是露比 然后是Scala。 一些Haskell,最近,...
  • 还记得你学习的第一门编程语言是什么吗? 就从 11 级软件工程出身的笔者而言,...随之而来的是,作为 AI 领域的首选编程语言 Python 也水涨船高,甚至不少高校将其取代了 Java 的基本教学任务。对于这种现状,本文作
  • 第1章 引论  递归的四条基本法则  1. 基准情况。必须总要有某些基准情况,它无需递归就能解出。  2. 不断推进。对于那些需要递归求解的情况,每一次递归调用都必需要使状况朝向一种...Java泛型  class MyClass>
  • 原文:Businesses stick with Java, Python, and C ...但是他们的雇主依然倾向于使用比较成熟的语言,例如Java。Python变得越来越流行,很多项目开始使用这种编程语言。技术招聘平台HackerRank基于3000个对雇主的...
  • 最近开始流行区分Java平台和Java语言,但很多Java开发者还是不能确定如何在Java应用程序开发中结合脚本。本篇文章,Gregor Roth给出了在Java平台上使用脚本的方法。通过这篇文章,你可以了解怎样在你的Java应用程序...
  • 全文共2322字,预计学习时长6分钟为了应对新工作,笔者在过去两周一直在重新熟悉一位老朋友:JAVA。我以JAVA开启了我的软件事业,与之共行了两年半左右的时间。但是随着容器和微服务的...
  • javac - Java 编程语言编译器的使用文档 来自: 2005-05-06 23:32:01 点击: 1 结构javac [ options ] [ sourcefiles ] [ @files ]参数可按任意次序排列。options 命令行选项。 sourcefiles 一个或多个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,466
精华内容 6,986
关键字:

java语言冗长

java 订阅