JavaSE——面向对象高级（继承、final关键字、抽象类与接口、多态、Object类、内部类、包装类、可变参数）

第3节 面向对象高级

一、继承

1.1 概述和使用

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

格式如下所述：

class 父类 {
}class 子类 extends 父类 {
}

继承的限制：Java中只有单继承，多重继承，没有多继承。

看下面的例子：

package com.kaikeba.objectoriented.senior;public class inherit2 {public static void main(String[] args) {Student2 s = new Student2();s.setName("张三");s.setAge(18);s.say();}
}class Person2 {private String name;private int age;public String sex;public Person2() {}public Person2(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void say() {System.out.println("我是："+name+"，我今年"+age+"岁了");}
}class Student2 extends Person2 {
}

结果如下：

我是：张三，我今年18岁了

子类继承父类后，可以使用父类的属性和方法（public和protected修饰的）。

1.2 子类实例化内存分析

Student s = new Student()内部的创建过程：

1、先查看Student是否有父，若有，先在堆内存中创建一个父对象的空间，再创建一个Student对象空间，同时super指向父类对象，可以找到父对象。

在这里插入图片描述

2、s.setName("张三");若发现Student类中没有setName方法，就会使用Person的setName，并将name赋值到Person对象中，若有就用自己的，这个后面说。

在这里插入图片描述

补充： 父类中只有用public和protected修饰符修饰的属性和方法才可以被子类使用，比如Student对象无法使用Person私有的属性，但是可以通过set和get来操作属性。

1.3 super关键字

this表示当前对象：

    - this.属性 区别成员变量和局部变量

    - this.() 调用本类的某个方法

    - this() 表示调用本类构造方法，只能用在构造方法的第一行语句。

    - this关键字只能出现在非static修饰的代码中

super表示父类对象：

    - super.属性 表示父类对象中的成员变量

    - super.方法()表示父类对象中定义的方法

    - super() 表示调用父类构造方法

        可以指定参数，比如super("Tom",23);

        任何一个构造方法的第一行默认是super();

        可以写上，如果未写，会隐式调用super();

    - super()只能在构造方法的第一行使用。

    - this()和super()都只能在构造的第一行出现，所以只能选择其一。写了this()就不会隐式调用super()。

super调用父类构造方法，必须满足父类中有对应的构造方法，见下述代码：

package com.kaikeba.objectoriented.senior;public class inherit2 {public static void main(String[] args) {Student2 s = new Student2();s.say();}
}class Person2 {private String name;private int age;public String sex;public Person2() {}public Person2(String name, int age) {this.name = name;this.age = age;}public void say() {System.out.println("我是："+name+"，我今年"+age+"岁了，性别："+sex);}
}class Student2 extends Person2 {public Student2() {//super调用了父类的全参构造方法super("无名称", 1);super.sex = "男";}
}

结果如下：

我是：无名称，我今年1岁了，性别：男

1.4 重写（Override）与重载（Overload）

子类中可能需要对父类的一些方法进行修改，这就是重写的概念：

重写（override）规则：

  • 1.参数列表必须完全与被重写方法的相同；

  • 2.返回类型必须完全与被重写方法的返回类型相同；

  • 3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected；

  • 4.父类的成员方法只能被它的子类重写。

  • 5.声明为static和private的方法不能被重写，但是能够被再次声明。

package com.kaikeba.objectoriented.senior;public class override {public static void main(String[] args) {Student3 s = new Student3();s.say();}
}class Person3 {//父类方法public void say() {System.out.println("锄禾日当午");}
}class Student3 extends Person3 {//子类对父类方法的重写public void say() {System.out.println("参数列表 与 返回值类型 必须相同");}//    void say() {
//        System.out.println("权限修饰符级别不能更低");
//    }
}

面试中可能会考察重载（Overload）与重写（Override）的区别：

1. 发生的位置：

    1. 重载：一个类中

    2. 重写：子类对父类方法进行重写

2. 参数列表规则：

    1. 重载：必须不同（长度，类型，顺序不同均可）

    2. 重写：必须相同

3. 返回值类型：

    1. 重载：与返回值类型无关

    2. 重写：返回值类型必须一致

4. 访问权限：

    1. 重载：与访问权限无关

    2. 重写：子类的方法权限必须高于等于父类的方法权限

5. 异常处理：

    1. 重载：与异常无关

    2. 重写：异常范围可以更小，但是不能抛出新的异常

二、final关键字

  1. final关键字用于修饰属性、变量：

    变量成为常量，无法对其再次进行赋值；

    final修饰的局部变量只能赋值一次（可以先声明后赋值）；

    final修饰的成员属性，必须在声明时赋值。

public class finalkeyword {final int a = 10;   //成员属性public static void main(String[] args) {final int a = 10;   //局部变量}
}

    全局常量（public static final）

        常量的命名规则：

            由一个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写，例如：SQL_INSERT。

  1. final用于修饰类：

    final修饰的类，不可以被继承。

  1. final用于修饰方法：

    final修饰的方法，不可以被子类重写。

三、抽象类

3.1 概念

抽象类必须使用abstract class声明；

格式：

abstract class 类名{    //抽象类
}

3.2 抽象方法

只声明而未实现的方法称为抽象方法（未实现指的是：没有"{}"方法体 ），抽象方法必须使用abstract关键字声明。

格式：

abstract class 类名 {  //抽象类public abstract void 方法名();  //抽象方法，只声明而未实现
}

一个抽象类中可以没有抽象方法，抽象方法必须写在抽象类或者接口中。

3.3 几个原则

  1. 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成；

  2. 一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写抽象类中的全部抽象方法。

3.4 常见问题

  1. 抽象类能否使用final声明？

    不能，因为final修饰的类是不能被子类继承的，而抽象类必须有子类才有意义，所以不能。

  1. 抽象类是否有构造方法？

    能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。

    

3.5 抽象类与普通类的区别

  1. 抽象类必须用public或protected修饰（如果为private修饰，那么子类无法继承，也就无法实现其抽象方法），默认缺省为public。

  2. 抽象类不可以使用new关键字创建对象，但是在子类创建对象时，抽象父类也会被JVM实例化。

  3. 如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类。

四、接口

4.1 概念

   如果一个类中全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。

定义格式：

interface 接口名称{全局常量;抽象方法；
}

接口的抽象程度更高，后续项目中使用的也比抽象类更多一些。

4.2 面向接口编程思想

   这种思想是定义（规范，约束）与实现（名实分离原则）的分离。从整体的角度先构思好接口，然后再去具体实现它。

优点：

  1. 降低程序的耦合性；

  2. 易于程序的扩展；

  3. 有利于程序的维护。

4.3 全局常量和抽象方法的简写

   因为接口本身都是由全局常量和抽象方法组成的，所以接口中的成员定义可以简写：
  1. 全局常量编写时，可以省略public static final关键字，例如：
public static final String INFO = "内容" ;
简写后：
String INFO = "内容" ;
  1. 抽象方法编写时，可以省略public abstract关键字，例如：
public abstract void print() ;
简写后：
void print() ;

4.4 接口的 实现implements 与 继承extends

接口可以多实现：
格式：class 子类 implements 父接口1,父接口2...{}
以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：class 子类 extends 父类 implements 父接口1,父接口2...{}

接口因为都是抽象部分， 不存在具体的实现， 所以允许多继承,例如：interface C extends A,B{}

实现后的接口是一个类，继承后的接口还是一个接口。

注意： 如果一个接口想要使用，必须依靠子类。子类（如果不是抽象类的话）要实现接口中的所有抽象方法。

4.5 接口和抽象类的区别

  1. 抽象类要被子类继承，接口要被类实现；

  2. 接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法；

  3. 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量；

  4. 抽象类使用继承来使用，无法多继承；接口使用实现来使用，可以多实现；

  5. 抽象类中可以包含static方法，但是接口中不允许（静态方法不能被子类重写，因此接口不能声明静态方法） ；

  6. 接口不能有构造方法，但是抽象类可以有。

五、多态

5.1 概念

   多态就是对象的多种表现形式（多种体现形态）。

5.2 多态的体现

对象的多态性 ：在类中有子类和父类之分，子类就是父类的一种形态，对象多态性就从此而来。

方法的重载和重写也是多态的一种，不过是方法的多态性 ：

     重载：一个类中方法的多态性体现

     重写：子父类中方法的多态性体现

5.3 多态的使用：对象的类型转换

类似于基本数据类型的转换：

向上转型 ：将子类实例变为父类实例

     格式：父类 父类对象名 = 子类实例 ;

向下转型 ：将父类实例变为子类实例

     格式：子类 子类对象 = (子类) 父类实例 ;

package com.kaikeba.objectoriented.senior;public class polymorphicDemo {/*** 父类引用指向子类对象* @param args*/public static void main(String[] args) {
//        Person5 p = null;
//        Student5 s = new Student5();
//        p = s;   //s是p的一种形态
//        p.say();Student5 a = new Student5();Nurse b = new Nurse();Person5 p1 = a;Person5 p2 = b;p1.say();p2.say();//        Student5 a2 = (Student5) p1;Student5 a3 = (Student5) p2;a3.say();}
}

Student实例可以向上转型为父类Person实例，Person实例也可以向下转型回Student实例，但是不能将Nurse实例转为Student实例。

5.4 instanceof

作用：

    判断某个对象是否是指定类的实例，则可以使用instanceof关键字。

格式：

    实例化对象 instanceof 类 //此操作返回boolean类型的数据

package com.kaikeba.objectoriented.senior;public class instanceofDemo {public static void main(String[] args) {Nurse6 n = new Nurse6();say(n);Student6 s = new Student6();say(s);}public static void say(Person6 p) {//如何判断传入的对象是此类型的哪种形态（哪个子类的对象）if(p instanceof Student6) {Student6 s = (Student6) p;s.say();}else {System.out.println("必须传入学生形态，才可以执行");}}
}

结果如下：

必须传入学生形态，才可以执行
锄禾日当午

六、Object类

6.1 概念

   Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类。 

例如我们定义了一个类：
public class Person {
}其实它被使用时是这样的：
public class Person extends Object {
}

观察Object类的构造器：只有一个无参构造方法。

在这里插入图片描述

6.2 Object的多态

   由于Object是所有类的父类，使用Object可以接收任意的引用数据类型，观察下面的代码：

package com.kaikeba.objectoriented.senior;public class objectDemo {public static void main(String[] args) {String text = "123";say(text);int a = 10;say(a);}public static void say(Object o) {System.out.println(o);}
}

6.3 toString方法

Object类下有一些方法：

在这里插入图片描述

目前只要掌握toString和equals即可，而且可以查看java API中文手册，或者查看源码来了解方法的具体作用。

先来看一下toString的源码：

public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

返回对象的字符串表示形式，默认的是包名类名@哈希码 ，观察如下代码：

package com.kaikeba.objectoriented.senior;import java.util.Objects;public class Person7 {private String name;private int age;public Person7() {}public Person7(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

package com.kaikeba.objectoriented.senior;public class toStringDemo {public static void main(String[] args) {Person7 p = new Person7("张三",18);//System.out.println方法中默认调用了toString方法System.out.println(p);}
}

输出的结果为：

com.kaikeba.objectoriented.senior.Person7@16e8e0a

这样对对象的描述一般不是很直观，所以一般建议继承的子类都要重写toString方法，在Person7类中加入重写方法：

    @Overridepublic String toString() {return "Person7{" +"name='" + name + '\'' +", age=" + age +'}';}

输出结果就变为：

Person7{name='张三', age=18}

6.4 equals方法

   指示某个其他对象是否“等于”此对象。

查看一下equals的源码：

public boolean equals(Object obj) {return (this == obj);
}

默认的比较方式为 “==”，对于任何非空引用值x和y ，当且仅当x和y引用同一对象时，此方法返回true 。

但是这样一般不太合理，一般而言，两个对象的每个属性都相同，那么我们就认为其相同，而不是非要两个引用都指向同一个对象才相同，所以一般建议重写Object类中的equals方法。

equals方法重写的五个特性：（面试可能会问）

  • 自反性 ：对于任何非空的参考值x，x.equals(x)应该返回true；

  • 对称性 ：对于任何非空的引用值x和y，x.equals(y)应该返回true当且仅当y.equals(x)返回true；

  • 传递性 ：对于任何非空引用值x，y和z，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)应该也返回true；

  • 一致性 ：对于任何非空引用值x和y，多次调用x.equals(y)始终返回true或始终返回false，前提是未修改对象上的equals比较中使用的信息；

  • 非空性 ：对于任何非空的参考值x，x.equals(null)应该返回false。

我们将上述的main函数修改如下：

package com.kaikeba.objectoriented.senior;public class toStringDemo {public static void main(String[] args) {Person7 p1 = new Person7("张三",18);System.out.println(p1);Person7 p2 = new Person7("张三",18);System.out.println(p2);System.out.println(p1.equals(p2));}
}

结果如下所示：

Person7{name='张三', age=18}
Person7{name='张三', age=18}
false

因为equals默认的是使用了==来比较，p1和p2虽然属性值一样，但是毕竟是两个对象，地址值不一样，所以返回false；如果想通过属性值来比较两个对象是否相同，可以通过重写equals方法来实现，在Person7类中重写如下方法：

    @Overridepublic boolean equals(Object o) {//如果两个引用指向一样，则肯定相同if (this == o) return true;//若o为空（能到这this肯定不为空）或this和o的类型不一致，肯定不同if (o == null || getClass() != o.getClass()) return false;Person7 person7 = (Person7) o;//类型一致，比较属性值是否一致return age == person7.age && Objects.equals(name, person7.name);}

或：

public boolean equals(Object o) {if(this == o) {return true;}if(o == null) {return fasle;}if(o instanceof Person7) {Person7 p2 = (Person7) o;if(this.name.equals(p2.name) && this.age == p2.age) {return true;} }return false;
}

在运行main函数，结果就变为true了，这也是比较合理的：

Person7{name='张三', age=18}
Person7{name='张三', age=18}
true

七、内部类

7.1 概念

   在Java中，可以将**一个类定义在另一个类里面或者一个方法里面** ，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：

    1. 成员内部类

    2. 局部内部类

    3. 匿名内部类

    4. 静态内部类

7.2 成员内部类

   成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：

class Outer {private double x = 0;public Outer(double x) {this.x = x;}class Inner {    //内部类public void say() {System.out.println("x=" + x);}}
}

如何使用成员内部类：

Outer o = new Outer();    //先创建外部类对象
Outer.Inner i = o.new Inner();    //通过外部类对象来new内部类对象

特点：

   成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法

看一个完整的例子：

package com.kaikeba.objectoriented.senior;public class Outer {private int x;public int getX() {return x;}public void setX(int x) {this.x = x;}class Inner {private int x = 200;public void say() {System.out.println("内部类的变量x的值：" + x);System.out.println("外部类的变量x的值：" + Outer.this.x);}}
}
package com.kaikeba.objectoriented.senior;public class memberInnerClass {public static void main(String[] args) {Outer o = new Outer();o.setX(100);Outer.Inner i = o.new Inner();i.say();}
}

结果如下：

内部类的变量x的值：200
外部类的变量x的值：100

7.3 局部内部类

   局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或该作用域内。

看个例子直观感受一下：

package com.kaikeba.objectoriented.senior;public class localInnerClass {public static void main(String[] args) {class Person{public void say() {System.out.println("锄禾日当午");}}Person p = new Person();p.say();}
}

类的优点是复用性高，但是局部内部类出了方法或者作用域就不能用了，所以它不具备较高的复用性，使用的较少，但是创建一个只使用一次的对象可以考虑使用局部内部类：

package com.kaikeba.objectoriented.senior;public class localInnerClass2 {public static void main(String[] args) {class ChildImp implements Child {@Overridepublic void say() {System.out.println("新编写的局部内部类的say方法内部"+a);}}ChildImp c = new ChildImp();haha(c);}public static void haha(Child c) {}
}

注意：局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

7.4 匿名内部类

   匿名内部类由于没有名字，所以它的创建方式有点奇怪，创建格式如下：

new 父类构造器(参数列表) 实现接口()
{//匿名内部类的类体部分
}

在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能继承一个父类或者实现一个接口，同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用，当然这个引用时隐式的。

package com.kaikeba.objectoriented.senior;public class anonymousInnerClass {public static void main(String[] args) {Child c = new Child() {@Overridepublic void say() {System.out.println();}};haha(c);}public static void haha(Child c) {}
}

注意：

  1. 使用匿名内部类是，我们必须继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或实现一个接口；

  2. 匿名内部类中是不能定义构造函数的；

  3. 匿名内部类中不能存在任何的静态成员变量和静态方法；

  4. 匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效；

  5. 匿名内部类不能是抽象的，它必须要实现继承的类或者实现接口的所有抽象方法；

  6. 只能访问final型的局部变量 （面试题）：因为内部类会被单独编译成一个字节码文件，为了保证这个单独的文件中用到的变量，与外面的变量的值绝对是一致的，系统从规则上限制了这个变量的值不可更改。

7.5 静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。

静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。

使用格式如下所示：

public class Test {public static void main(String[] args) {Outer.Inner inner = new Outer.Inner();}
}class Outer {public Outer() {}static class Inner {public Inner() {}}
}

八、包装类

8.1 概述

   在java中有一个设计的原则“一切皆对象”，那么这样一来Java中的基本的数据类型，就完全不符合这种设计思想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了**八种基本数据类型的包装类** 。

在这里插入图片描述

   以上的八种包装类，可以将基本数据类型按照类的形式进行操作。也可以分为两种大的类型：

  • Number：Byte、Short、Integer、Long、Float、Double都是Number的子类表示是一个数字。

  • Object：Character、Boolean都是Object的直接子类。

包装类也是类，其在内存中的表示和一般的类一样：

在这里插入图片描述

8.2 装箱和拆箱操作

以下以Integer和Float为例进行操作：

  • 装箱：将一个基本数据类型变为包装类；

  • 拆箱：讲一个包装类变为一个基本数据类型；

看如下代码：

package com.kaikeba.objectoriented.senior;public class wrapperClass {public static void main(String[] args) {//手动装箱JDK1.5之前Integer i = new Integer(200);//手动拆箱JDK1.5之前int a = i.intValue();//自动装箱JDK1.5开始Integer j = 200;//自动拆箱JDK1.5开始int b = j;}
}

在JDK1.5之前，如果想要装箱，直接使用各个包装类的构造方法即可，例如：int temp = 10;    //基本数据类型Integer x = new Integer(temp);    //将基本数据类型变为包装类
在JDK1.5，Java新增了自动装箱和自动拆箱，可以直接通过包装类进行四则运算和自增自减操作，例如：Float f = 10.3f;    //自动装箱float x = f;        //自动拆箱System.out.println(f * f);    //直接利用包装类完成System.out.println(x * x);    //利用基本数据类型完成

因为所有的数值型的包装类都是Number的子类，Number的类中定义了如下的操作方法，以下的全部方法都是进行拆箱操作：

在这里插入图片描述

可以拆箱为不同的基本数据类型。

8.3 字符串转换

使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型 ，此点一般在接收输入数据上使用较多。

在Integer类中提供了以下的操作方法：

public static int parseInt(String s):将String变为int型数据

在Float类中提供了以下的操作方法：

public static float parseFloat(String s):将String变为float型数据

…

观察如下代码：

package com.kaikeba.objectoriented.senior;import java.util.Scanner;public class wrapperClass2 {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.println("请输入内容：");String text = input.nextLine();int x = Integer.parseInt(text);System.out.println(x+1);}
}

结果如下：

请输入内容：
100
101

nextLine接收的是String类型的输入，如果直接+1则当成字符串来操作了，需要用parseInt转为int类型，然后+1就是算术运算了。

九、可变参数

一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数 。

语法：返回值类型 方法名称(数据类型...参数名称) {//参数在方法内部，以数组的形式来接收}注意：可变参数只能出现在参数列表的最后。 

package com.kaikeba.objectoriented.senior;public class variableParameters {public static void main(String[] args) {System.out.println(sum());System.out.println(sum(100));System.out.println(sum(100, 200));System.out.println(sum(100, 200, 300));System.out.println(sum(100, 200, 300, 500));}/*** int... nums，表示的是可变参数，调用时可以传递0-n个数字* 在方法的内部，可变参数以数组作为载体体现*/public static int sum(int... nums) {int n = 0;for(int i=0; i < nums.length; i++) {n += nums[i];}return n;}
}

结果如下所示：

0
100
300
600
1100

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/491547.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

word的公式后加编码后自动变小

word的公式后加编码后自动变小

如图所示&#xff0c;在公式后面加编码后公式也变小了&#xff1a; 加编码前&#xff1a; 加编码后&#xff1a; 采用样式分隔符&#xff08;Ctrlaltenter&#xff09;即可解决&#xff0c;输完公式后&#xff0c;按enter转行&#xff0c;输入你要的东西&#xff08;编号什么的…
阅读更多...
人工智能70年：科幻和现实的交融

人工智能70年：科幻和现实的交融

文章素材来源&#xff1a;BBC图片来源&#xff1a;网络【导读】人类飞跑着进入人工智能&#xff08;AI&#xff09;时代。粗略估算现在人们日常生活中有20多种寻常的AI&#xff0c;从垃圾邮件过滤器到叫车软件。AI被分为两类&#xff0c;这些执行具体任务的AI属于“弱人工智能”…
阅读更多...
vim 插件之commentary

vim 插件之commentary

下载地址 http://www.vim.org/scripts/script.php?script_id3695 如果是使用vundle来管理这个插件的话&#xff0c;你可以添加如下配置 tpope/vim-commentary 这个插件可以根据你当前打开的文件类型&#xff0c;来选择相应的注释方式。 使用的命令是 \\位移 比如&#xff0c;…
阅读更多...
JavaSE——异常处理（异常简介、try-catch-finally、throws、throw）

JavaSE——异常处理（异常简介、try-catch-finally、throws、throw）

第4节 异常处理 异常处理学习的目标&#xff1a; 明确说明是异常&#xff08;重点&#xff09; 能辨识出常见的异常及其含义&#xff08;熟悉&#xff09; 理解异常产生的原理&#xff08;了解&#xff09; 能处理异常&#xff08;重点&#xff09; 能够自定义异常&#x…
阅读更多...
专访「算法之父」Michael Saunders：人工智能未来的突破点可能在自动驾驶

专访「算法之父」Michael Saunders：人工智能未来的突破点可能在自动驾驶

来源&#xff1a;雷锋网 AI 科技评论雷锋网 AI 科技评论按&#xff0c;4 月 25 日&#xff0c;在由涂鸦智能联合知名财经媒体《新财富》、人工智能领域知名媒体《全球智能化商业》共同举办的「全球智能化商业峰会」上&#xff0c;斯坦福大学荣誉教授、新西兰皇家学会荣誉成员、…
阅读更多...
从指南针到北斗：中国导航系统促进世界互联互通

从指南针到北斗：中国导航系统促进世界互联互通

6月11日&#xff0c;在维也纳联合国国际会议中心&#xff0c;联合国外层空间事务办公室主任迪皮波&#xff08;右&#xff09;参观中国古代计时装置水运仪象台。本报记者 冯雪珺摄来源&#xff1a;人民日报核心阅读中国卫星导航系统管理办公室在维也纳联合国国际会议中心举办“…
阅读更多...
JavaSE——常用类库(上)（泛型、Objects、Math、ArraysBigDecimal类）

JavaSE——常用类库(上)（泛型、Objects、Math、ArraysBigDecimal类）

第1节 常用类库&#xff08;上&#xff09; 面向对象更多是思想上的东西&#xff0c;常用类库更多是工具上的东西&#xff0c;熟能生巧&#xff0c;多整理笔记。 一、泛型 1.1 概述 泛型&#xff0c;即“参数化类型”。就是将类型由原来具体类型进行参数化 &#xff0c;类似…
阅读更多...
朗兰兹纲领：关于数学大一统的伟大构想

朗兰兹纲领：关于数学大一统的伟大构想

麦克斯韦方程组来源&#xff1a;今日头条我们经常聊到物理学家都在追寻物理学的大一统&#xff0c;物理学的第一次大一统是麦克斯韦的麦克斯韦方程组&#xff0c;将电学与磁学相统一&#xff0c;建立了电磁学理论&#xff0c;后来&#xff0c;爱因斯坦想继续完成麦克斯韦未竟之…
阅读更多...
JavaSE——常用类库(下)（Date、DateFormat、Calendar、System类）

JavaSE——常用类库(下)（Date、DateFormat、Calendar、System类）

第1节 常用类库&#xff08;下&#xff09; 六、java.util.Date Date类表示特定的时刻&#xff0c;精度为毫秒。 在JDK 1.1之前&#xff0c; Date类还有两个附加功能。 它允许将日期解释为年&#xff0c;月&#xff0c;日&#xff0c;小时&#xff0c;分钟和秒值。 它还允许…
阅读更多...
世界隐形冠军比拼：德国1307家、美国366家、中国68家

世界隐形冠军比拼：德国1307家、美国366家、中国68家

来源&#xff1a;股权投资论坛目录一、隐形冠军的概念二、隐形冠军的四个特征三、隐形冠军为何隐形四、隐形冠军到底有多牛五、如何成为隐形冠军六、中国隐形冠军多吗1隐形冠军的概念“隐形冠军”这个概念是赫尔曼西蒙教授提出的。1986年&#xff0c;他在研究德国出口数据时发现…
阅读更多...
JavaSE——常用类库（String类）

JavaSE——常用类库（String类）

第1节 常用类库——String 因为String相对之前的类来说更加常用一些&#xff0c;所以对字符串类进行专门的整理。 1. 概述 String类表示字符串&#xff0c;Java中的所有字符串文字都实现为此类的实例。字符串是不变的&#xff0c;它们的值在创建后无法更改 。因为它的创建是通…
阅读更多...
VVDocumenter 使用

VVDocumenter 使用

函数说明文档插件下载链接 https://github.com/onevcat/VVDocumenter-Xcode下载后&#xff0c;直接运行项目升级Xcode后可能不能再次使用&#xff0c;需要做一些处理从Xcode 5开始&#xff0c;苹果要求加入UUID证书从而保证插件的稳定性。因此Xcode版本更新之后需要在VVDocumen…
阅读更多...
大自然创作的分形艺术

大自然创作的分形艺术

来源&#xff1a;http://blog.sciencenet.cn/blog-420554-363521.html数学上的分形 (Fractal) 是指“一个粗糙或零碎的几何形状&#xff0c;可以分成数个部分&#xff0c;且每一部分都&#xff08;至少会大略&#xff09;是整体缩小尺寸的形状”。数学家们已经创作出许多美丽的…
阅读更多...
JavaSE——类集（上）（Collection、List、Iterator、forEach）

JavaSE——类集（上）（Collection、List、Iterator、forEach）

第2节 集合&#xff08;上&#xff09; 因为已经有数据结构的基础&#xff0c;前面有关数据结构的知识就不单独整理了&#xff0c;直接上Java的集合类的知识。 一、类集&#xff08;集合类&#xff09; 1.1 集合概述 集合&#xff1a; 集合是java中提供的一种容器&#xff…
阅读更多...
第二个spring冲刺总结

第二个spring冲刺总结

讨论成员&#xff1a;罗凯旋、罗林杰、吴伟锋、黎文衷 第二阶段总体是做到了四则运算的demo&#xff0c;,包括APP进入动画&#xff0c;以及界面的基本效果设计&#xff0c;还有能进行综合计算&#xff08;选择题&#xff0c;可以 自动生成简单&#xff0c;容易&#xff0c;困难…
阅读更多...
图灵奖得主姚期智：求解人工智能的中国答案

图灵奖得主姚期智：求解人工智能的中国答案

来源&#xff1a;清华大学他是“图灵奖”创立以来首位获奖的亚裔学者&#xff0c;也是迄今为止获此殊荣的唯一华裔计算机科学家。2004年从普林斯顿辞去终身教职回到清华任教。2005年&#xff0c;他为清华本科生创立了计算机科学实验班“姚班”。如今&#xff0c;在中国乃至全球…
阅读更多...
JavaSE——类集（下）（Set、Comparable、Collections、Comparator、Map）

JavaSE——类集（下）（Set、Comparable、Collections、Comparator、Map）

第2节 集合&#xff08;下&#xff09; 一、Set接口 java.util.Set 接口和 java.util.List接口一样&#xff0c;同样继承自 Collection接口&#xff0c;它与Collection接口中的方法基本一致&#xff0c;并没有对 Collection接口进行功能上的扩充&#xff0c;只是比Collection…
阅读更多...
美国国家科学院发布《材料研究前沿：十年调查》

美国国家科学院发布《材料研究前沿：十年调查》

来源&#xff1a;中国科学院科技战略咨询研究院2月8日&#xff0c;美国国家科学院发布了针对材料研究的第三次十年调查《材料研究前沿&#xff1a;十年调查》报告。这次的调查主要评估了过去十年中材料研究领域的进展和成就&#xff0c;确定了2020-2030年材料研究的机遇、挑战和…
阅读更多...
JavaSE——IO（上）（File、字节流、字符流、转换流、打印流、缓存流）

JavaSE——IO（上）（File、字节流、字符流、转换流、打印流、缓存流）

第3节 IO&#xff08;上&#xff09; 一、File类与文件基本操作 在程序中经常需要用到文件的操作&#xff0c;Java有专门的类来进行文件的操作——File类。 1.1 File类概述 它是对文件和目录路径名的抽象表示。 即它本身不是一个文件&#xff0c;只是一个抽象表示&#xff…
阅读更多...
学习新技能时，大脑在如何发生改变？

学习新技能时，大脑在如何发生改变？

来源&#xff1a;中国生物技术网众所周知&#xff0c;无论是一项运动、一种乐器还是一门手艺&#xff0c;掌握一项新技能都是需要花费时间并进行训练的。虽然我们都知道健康的大脑能够应付的来&#xff0c;但是为了开发出新行为大脑如何发生改变科学家们对此仍知之甚少。近日&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023