精华内容
下载资源
问答
  • Java有很多强大的类类的强大得益于函数的强大。要想用好Java,就必须学好各类函数,可以使得程序更灵活简明。如果学过C++STL话,会发现很多类似之处,因为Java的容器是从STL衍生出来。 数学函数 ...

    前言

    Java有很多强大的类,类的强大得益于类内函数的强大。要想用好Java,就必须学好各类函数,可以使得程序更灵活简明。如果学过C++中STL的话,会发现很多类似之处,因为Java的容器是从STL中衍生出来的。

    数学函数

    三角函数

    • static double  sin(double a ) : 返回角的三角正弦
    • static  double cos(double a)  : 返回角的三角余弦
    • static  double tan(double  a)  : 返回角的三角正切
    • static  double asin(double a) :   返回角的反正弦
    • static  double acos(double a)  : 返回角的反余弦
    • static  double atan(double a)  : 返回角的反正切
    • static  double toRadians(double a) : 将角转换为弧度
    • static  doueble toDegrees(double a) : 将弧度转化为角

    指数函数

    • static  double exp(double a) : 用于获取e的a次方
    • static  double log(double a) : 即lna
    • static  double log10(double a) : 即log10a
    • static  double sqrt(double a ):用于取a的平方根
    • static  double cbrt(double a) : 用于取a的立方根
    • static  double pow(double a, double b) : 用于求a的b次方

    取整函数

    • static double ceil(double a):返回大于等于a的整数值,返回值类型为double;
    • static double floor(double a) : 返回小于等于a的整数值,返回值类型为double;
    • static double rint(double a) : 返回与a最接近的整数值,返回值类型为double;(如果两个同为整数且同样接近,选取偶数值的那个)
    • static int random( ):返回带正号的 double 值,该值大于等于 0.0 且小于 1.0。
    • static int round(double a ): 四舍五入,其值等于Math.floor(a + 0.5),返回值类型为long;
    • static long round(float a ):四舍五入, 其值等于Math.floor(a + 0.5),返回值类型为int;

    绝对值函数和最值函数

     

    • static 类型 abs(类型); 返回对应类型的绝对值
    • static 类型 min(类型1, 类型2)  ;返回对应类型的最小值
    • static 类型 max(类型1, 类型2)  ;返回对应类型的最大值

    String

    • substring

    public String substring(int beginIndex) ;返回类型为字符串,返回从第i个字符到末尾的字符。

    public String substring(int beginIndex, int endIndex);返回类型为字符串,返回从第i到j的字符,左闭右开。

    StringBuffer

    • revserse

    reverse()反转字符。

     

     

     

    展开全文
  • Java吸收了C++语言优点,也展现了其强大一面,我们能在各个地方看到其功能强大和简单易用两个特征,当然,也吸引了很多程序员注意力,所以就有人想了解Java的相关内容,今天就来讲讲Java的ArrayList 类的...

    【摘要】作为一门面向对象编程语言,Java吸收了C++语言的优点,也展现了其强大的一面,我们能在各个地方看到其功能强大和简单易用的两个特征,当然,也吸引了很多程序员的注意力,所以就有人想了解Java的相关内容,今天就来讲讲Java的ArrayList 类的相关内容。

    ArrayList 类实现了可变数组的大小,存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式,对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合,允许对集合中的元素进行快速的随机访问,不过,向 ArrayList 中插入与删除元素的速度相对较慢。

    ArrayList 类的常用构造方法有如下两种重载形式:

    ArrayList():构造一个初始容量为 10 的空列表。

    ArrayList(Collectionc):构造一个包含指定 Collection 元素的列表,这些元素是按照该 Collection 的迭代器返回它们的顺序排列的。

    ArrayList 类除了包含 Collection 接口中的所有方法之外,还包括 List 接口中提供的如表 1 所示的方法。

    ea1e7ab307b9dc654114fc5f009886da.png

    此方法返回此集合中指定索引位置的原元素

    List subList(int fromlndex, int tolndex)返回一个新的集合,新集合中包含 fromlndex 和 tolndex 索引之间

    的所有元素。包含 fromlndex 处的元素,不包含 tolndex 索引处的

    元素

    注意:当调用 List 的 set(int index, Object element) 方法来改变 List 集合指定索引处的元素时,指定的索引必须是 List 集合的有效索引。例如集合长度为 4,就不能指定替换索引为 4 处的元素,也就是说这个方法不会改变 List 集合的长度。

    例 1

    使用 ArrayList 类向集合中添加三个商品信息,包括商品编号、名称和价格,然后遍历集合输出这些商品信息。

    1)创建一个商品类 Product,在该类中定义 3 个属性和 toString() 方法,分别实现 setter/getter 方法。代码的实现如下:

    public class Product {

    // 商品类

    private int id; // 商品编号

    private String name; // 名称

    private float price; // 价格

    public Product(int id, String name, float price) {

    this.name = name;

    this.id = id;

    this.price = price;

    }

    // 这里是上面3个属性的setter/getter方法,这里省略

    public String toString() {

    return "商品编号:" + id + ",名称:" + name + ",价格:" + price;

    }

    }

    2)创建一个测试类,调用 Product 类的构造函数实例化三个对象,并将 Product 对象保存至 ArrayList 集合中。最后遍历该集合,输出商品信息。测试类的Java的ArrayList 类代码实现如下:

    public class Test {

    public static void main(String[] args) {

    Product pd1 = new Product(4, "木糖醇", 10);

    Product pd2 = new Product(5, "洗发水", 12);

    Product pd3 = new Product(3, "热水壶", 49);

    List list = new ArrayList(); // 创建集合

    list.add(pd1);

    list.add(pd2);

    list.add(pd3);

    System.out.println("*************** 商品信息 ***************");

    for (int i = 0; i < list.size(); i++) {

    // 循环遍历集合,输出集合元素

    Product product = (Product) list.get(i);

    System.out.println(product);

    }

    }

    }

    该示例中的 ArrayList 集合中存放的是自定义类 Product 的对象,这与存储的 String 类的对象是相同的。与 Set 不同的是,List 集合中存在 get() 方法,该方法可以通过索引来获取所对应的值,获取的值为 Object 类,因此需要将该值转换为 Product 类,从而获取商品信息。

    该程序的运行结果如下所示。

    *************** 商品信息 ***************

    商品编号:4,名称:木糖醇,价格:10.0

    商品编号:5,名称:洗发水,价格:12.0

    商品编号:3,名称:热水壶,价格:49.0

    例 2

    在使用 List 集合时需要注意区分 indexOf() 方法和 lastIndexOf() 方法。前者是获得指定对象的最小索引位置,而后者是获得指定对象的最大索引位置。前提条件是指定的对象在 List 集合中有重复的对象,否则这两个方法获取的索引值相同。

    下面的案例Java的ArrayList 类代码演示了 indexOf() 方法和 lastIndexOf() 方法的区别。

    public static void main(String[] args) {

    List list = new ArrayList();

    list.add("One");

    list.add("|");

    list.add("Two");

    list.add("|");

    list.add("Three");

    list.add("|");

    list.add("Four");

    System.out.println("list 集合中的元素数量:" + list.size());

    System.out.println("list 集合中的元素如下:");

    Iterator it = list.iterator();

    while (it.hasNext()) {

    System.out.print(it.next() + "、");

    }

    System.out.println("\n在 list 集合中'丨'第一次出现的位置是:" + list.indexOf("|"));

    System.out.println("在 list 集合中'丨'最后一次出现的位置是:" + list.lastIndexOf("|"));

    }

    上述代码创建一个 List 集合 list,然后添加了 7 个元素,由于索引从 0 开始,所以最后一个元素的索引为 6。输出结果如下:

    list 集合中的元素数量:7

    list 集合中的元素如下:

    One、|、Two、|、Three、|、Four、

    在 list 集合中'|'第一次出现的位置是:1

    在 list 集合中'|'最后一次出现的位置是:5

    例 3

    使用 subList() 方法截取 List 集合中部分元素时要注意,新的集合中包含起始索引位置的元素,但是不包含结束索引位置的元素。例如,subList(1,4) 方法实际截取的是索引 1 到索引 3 的元素,并组成新的 List 集合。

    下面的案例Java的ArrayList 类代码演示了 subList() 方法的具体用法。

    public static void main(String[] args) {

    List list = new ArrayList();

    list.add("One");

    list.add("Two");

    list.add("Three");

    list.add("Four");

    list.add("Five");

    list.add("Six");

    list.add("Seven");

    System.out.println("list 集合中的元素数量:" + list.size());

    System.out.println("list 集合中的元素如下:");

    Iterator it = list.iterator();

    while (it.hasNext()) {

    System.out.print(it.next() + "、");

    }

    List sublist = new ArrayList();

    sublist = list.subList(2, 5); // 从list集合中截取索引2~5的元素,保存到sublist集合中

    System.out.println("\nsublist 集合中元素数量:" + sublist.size());

    System.out.println("sublist 集合中的元素如下:");

    it = sublist.iterator();

    while (it.hasNext()) {

    System.out.print(it.next() + "、");

    }

    }

    Java的ArrayList 类输出结果如下:

    list 集合中的元素数量:7

    list 集合中的元素如下:

    One、Two、Three、Four、Five、Six、Seven、

    sublist 集合中元素数量:3

    sublist 集合中的元素如下:

    Three、Four、Five、

    以上就是有关Java的ArrayList 类的相关内容,随着我们对Java讲解的深入,相信大家很慢慢了解它的功能,毕竟这是一款允许程序员以优雅的思维方式进行复杂编程的软件,当然,我们还会为大家带来更多的教学内容,请大家持续关注环球网校的相关内容,小编在此祝大家Java的学习之路顺利。

    展开全文
  • equal函数比较的到底是什么,很明显是比较的值,但是什么值?与==比较的堆中的内存地址不同,其比较的是对象的值,包括各个...java中的数据类型,可分为两:1.基本数据类型,也称原始数据类型。byte,short,char,...

    equal函数比较的到底是什么,很明显是比较的值,但是什么值?与==比较的堆中的内存地址不同,其比较的是对象的值,包括各个属性的值。我们在重新overriding此方法时首先要判断是否为同一对象,如果是同一对象那么肯定返回为true,如果不是但比较的属性相同,那么对象“相等”,否则返回false。

    java中的数据类型,可分为两类:

    1.基本数据类型,也称原始数据类型。byte,short,char,int,long,float,double,boolean

    他们之间的比较,应用双等号(==),比较的是他们的值。

    2.复合数据类型(类)

    当他们用(==)进行比较的时候,比较的是他们在内存中的存放地址,所以,除非是同一个new出来的对象,他们的比较后的结果为true,否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的,在Object中的基类中定义了一个equals的方法,这个方法的初始行为是比较对象的内存地 址,但在一些类库当中这个方法被覆盖掉了,如String,Integer,Date在这些类当中equals有其自身的实现,而不再是比较类在堆内存中的存放地址了。

    对于复合数据类型之间进行equals比较,在没有覆写equals方法的情况下,他们之间的比较还是基于他们在内存中的存放位置的地址值的,因为Object的equals方法也是用双等号(==)进行比较的,所以比较后的结果跟双等号(==)的结果相同。

    1 public class TestString {

    2 public static void main(String[] args) {

    3 String s1 = "Monday";

    4 String s2 = "Monday";

    5 if (s1 == s2)

    6 {

    7 System.out.println("s1 == s2");}

    8 else{

    9 System.out.println("s1 != s2");}

    10 }

    11 }

    编译并运行程序,输出:s1 == s2说明:s1 与 s2 引用同一个 String 对象 -- "Monday"!

    2.再稍微改动一下程序,会有更奇怪的发现:

    public class TestString {

    public static void main(String[] args) {

    String s1 = "Monday";

    String s2 = new String("Monday");

    if (s1 == s2)

    {System.out.println("s1 == s2");}

    else

    {System.out.println("s1 != s2");}

    if (s1.equals(s2)) {System.out.println("s1 equals s2");}

    else{

    System.out.println("s1 not equals s2");}

    }

    }

    我们将s2用new操作符创建

    程序输出:

    s1 != s2

    s1 equals s2

    说明:s1 s2分别引用了两个"Monday"String对象

    3. 字符串缓冲池

    原来,程序在运行的时候会创建一个字符串缓冲池当使用 s2 = "Monday" 这样的表达是创建字符串的时候,程序首先会在这个String缓冲池中寻找相同值的对象,在第一个程序中,s1先被放到了池中,所以在s2被创建的时候,程序找到了具有相同值的 s1

    将s2引用s1所引用的对象"Monday"

    第二段程序中,使用了 new 操作符,他明白的告诉程序:"我要一个新的!不要旧的!"于是一个新的"Monday"sting对象被创建在内存中。他们的值相同,但是位置不同,一个在池中游泳一个在岸边休息。哎呀,真是资源浪费,明明是一样的非要分开做什么呢?

    4.再次更改程序:

    public class TestString {

    public static void main(String[] args) {

    String s1 = "Monday";

    String s2 = new String("Monday");

    s2 = s2.intern();

    if (s1 == s2)

    {System.out.println("s1 == s2");}

    else

    {System.out.println("s1 != s2");}

    if (s1.equals(s2)) {System.out.println("s1 equals s2");}

    else{

    System.out.println("s1 not equals s2");}

    }

    }

    这次加入:s2 = s2.intern();

    程序输出:

    s1 == s2

    s1 equals s2

    原 来,(java.lang.String的intern()方法"abc".intern()方法的返回值还是字符串"abc",表面上看起来好像这个方 法没什么用处。但实际上,它做了个小动作:检查字符串池里是否存在"abc"这么一个字符串,如果存在,就返回池里的字符串;如果不存在,该方法会 把"abc"添加到字符串池中,然后再返回它的引用。 )

    String.intern();

    再补充介绍一点:存在于.class文件中的常量池,在运行期间被jvm装载,并且可以扩充。String的intern()方法就是扩充常量池的一个方法;当一个String实例str调用intern()方法时,java查找常量池中是否有相同unicode的字符串常量,如果有,则返回其引用,如果没有,则在常量池中增加一个unicode等于str的字符串并返回它的引用。

    例3:

    String s0=”kvill”;

    String s1=new String(“kvill”);

    String s2=new String(“kvill”);

    System.out.println(s0==s1);

    S1.intern();

    S2=s2.intern();

    System.out.println(s0==s1);

    System.out.prntln(s0==s1.intern());

    System.out.println(s0==s2);

    结果为:

    False

    False //虽然执行了s1.intern(),但它的返回值没有赋给s1

    True

    True

    最后再破除一个错误的理解:

    有人说,“使用String.intern()方法可以将一个String类保存到一个全局的String表中,如果具有相同值的unicode字符串已经在这个表中,那么该方法返回表中已有字符串的地址,如果在表中没有相同值的字符串,则将自己的地址注册到表中”如果把这个全局的String表理解为常量吃的话,最后一句话“如果在表中没有相同值的字符串,则将自己的地址注册到表中”是错的。

    例4:

    String s1=new String(“kvill”);

    String s2=s1.intern();

    System.out.println(s1==s1.intern());

    System.out.println(s1+” ”+s2);

    System.out.println(s2==s1.intern());

    结果是:

    False

    Kvill kvill

    True

    我们没有声明一个”kvill”常量,所以常量池中一开始没有”kvill”的,当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量,原来的不在常量池中的”kvill”仍然存在,也就不是“把自己的地址注册到常量池中”了。

    例5:

    String str1=”java”;

    String str2=”blog”;

    String s=str1+str2;

    System.out.println(s==”javablog”);

    结果是false。Jvm确实对型如String str1=”java”;的String对象放在常量池里,但是它是在编译时那么做的,而String s=str1+str2;是在运行时刻才能知道,也就是说str1+str2是在堆里创建的,所以结果为false了。

    展开全文
  • 面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。过程其实就是函数;对象是将函数等一些内容进行了封装。2,创建一个对象的时候...

    1,面向对象和面向过程

    Java是完全的面向对象的语言。

    面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。

    面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。

    过程其实就是函数;对象是将函数等一些内容进行了封装。

    2,创建一个对象的时候内存都做了什么

    1:先将硬盘上指定位置的Person.class文件加载进内存。

    2:执行main方法时,在栈内存中开辟了main方法的空间(压栈-进栈),然后在main方法的栈区分配了一个变量p。

    3:在堆内存中开辟一个实体空间,分配了一个内存首地址值。new

    4:在该实体空间中进行属性的空间分配,并进行了默认初始化。

    5:对空间中的属性进行显示初始化。

    6:进行实体的构造代码块初始化。

    7:调用该实体对应的构造函数,进行构造函数初始化。()

    8:将首地址赋值给p ,p变量就引用了该实体。(指向了该对象)

    3,什么是匿名对象,什么时候用匿名对象?

    一个对象被new出来,只用一次,或者调用其方法,或者作为参数进行参数传递。如:

    new Car().run();// 只对Car的run方法进行调用

    new Car().num =5;

    system.out.println( new Data() ) // new的data也相当于一个匿名对象

    show( new Car() ) //作为参数进行传递

    4,什么是匿名类(也叫匿名内部类),什么时候用匿名类?

    匿名类(也叫匿名内部类)他是内部类的一种。匿名类在类中只能使用一次,它通常用来简化代码的编写,但使用匿名类还有一个前提条件:它必须继承一个父类或者一个接口,因此这个匿名类会被默认为这个父类或者接口的子类或实现类。

    Demo:

    1 packagecom.hpioneer.Demo;2

    3 public classTest_Inter {4 public static voidmain(String[] args) {5

    6 Outers o = newOuters();7 o.method();8 }9 }10

    11 interfaceInter{12 voidshow();13 }14

    15 classOuters {16

    17 class Inner implementsInter{18 public voidshow(){19 System.out.println("1");20 }21 }22

    23 public voidmethod(){24

    25 new Inter() { //实现Inter接口

    26 public void show() { //重写抽象方法

    27 System.out.println("print");28 }29 }.show();30 }31

    32

    33 }

    常见:

    1 new SetOnClickListener(newOnClickListener() {2

    3 //定义了一个实现事件监听的匿名类

    4 @Override5 public void onClick(View v) { //实现OnClickListener中的方法

    6

    7 newThread() {8 //定义了一个实现Thread的匿名类

    9 @Override10 public voidrun() { }11 }.start();12 }13 });

    5,什么是内部类?

    如果A类需要直接访问B类中的成员,而B类又需要建立A类的对象。这时,为了方便设计和访问,直接将A类定义在B类中。就可以了。A类就称为内部类。内部类可以直接访问外部类中的成员。而外部类想要访问内部类,必须要建立内部类的对象。

    Demo:

    packagecom.hpioneer.Demo;public classTest_Outer {public static voidmain(String[] args) {/*Outer.Inner oi = new Outer().new Inner();

    oi.show();*/Outer o= newOuter();

    o.print();

    }

    }classOuter{public int num = 10;classInner {public int num = 20;public voidshow() {int num = 30;

    System.out.println(num);//30

    System.out.println(this.num);//20

    System.out.println(Outer.this.num);//10

    }

    }public voidprint(){

    Inner i= newInner();

    i.show();

    }

    }

    5,抽象类

    将共性内容中的方法声明抽取,但是方法不一样,没有抽取,这时抽取到的方法,并不具体,需要被指定关键字abstract所标示,声明为抽象方法。抽象方法所在类一定要标示为抽象类,也就是说该类需要被abstract关键字所修饰。

    抽象类的特点:

    1:抽象方法只能定义在抽象类中,抽象类和抽象方法必须由abstract关键字修饰(可以描述类和方法,不可以描述变量)。

    2:抽象方法只定义方法声明,并不定义方法实现。

    3:抽象类不可以被创建对象(实例化)。

    4:只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后,该子类才可以实例化。否则,该子类还是一个抽象类

    抽象类和接口的区别:

    1:抽象类只能被继承,而且只能单继承。

    接口需要被实现,而且可以多实现。

    2:抽象类中可以定义非抽象方法,子类可以直接继承使用。

    接口中都有抽象方法,需要子类去实现。

    3:抽象类使用的是  is a 关系。

    接口使用的 like a 关系。

    4:抽象类的成员修饰符可以自定义。

    接口中的成员修饰符是固定的。全都是public的。

    6,构造函数

    Demo:

    1 packagecom.hpioneer.Demo;2

    3 public classTest_Employee {4 public static voidmain(String[] args) {5 Employee e1 = newEmployee();6 e1.setName("e1");7 e1.setId(1);8 e1.setSalary(2589.0);9 System.out.println(e1.toString());10

    11 Employee e2 = new Employee("e2",2,1256.1);12 System.out.println(e2.toString());13 }14

    15 }16

    17 classEmployee{18 String name;19 intid;20 doublesalary;21

    22 public Employee() { //无参构造

    23

    24 }25

    26 public Employee(String name, int id, double salary) { //有参构造

    27 this.name =name;28 this.id =id;29 this.salary =salary;30 }31

    32 publicString getName() {33 returnname;34 }35

    36 public voidsetName(String name) {37 this.name =name;38 }39

    40 public intgetId() {41 returnid;42 }43

    44 public void setId(intid) {45 this.id =id;46 }47

    48 public doublegetSalary() {49 returnsalary;50 }51

    52 public void setSalary(doublesalary) {53 this.salary =salary;54 }55

    56 @Override57 publicString toString() {58 return "name='" + name + '\'' +

    59 ", id=" + id +

    60 ", salary=" +salary ;61 }62 }

    展开全文
  • equal函数比较的到底是什么,很明显是比较的值,但是什么值?与==比较的堆中的内存地址不同,其比较的是对象的值,包括各个...java中的数据类型,可分为两:1.基本数据类型,也称原始数据类型。byte,short,char,...
  • Java中各个主要包作用(javax开头都是扩展包)   java.util是JAVA的utility工具包,包含一些使用工具,如定义系统特性、使用与日期日历相关的函数等。  java.lang是JAVA的language核心语言...
  • Java中各个主要包作用(javax开头都是扩展包)java.util是JAVA的utility工具包,包含一些使用工具,如定义系统特性、使用与日期日历相关的函数等。java.lang是JAVA的language核心语言包;如String、Math、Integer...
  • 前言:java的读写操作是学java开发的必经之路,Java.io包中包括许多提供许多有关文件的各个方面操作。下面就来总结下java的读写操作。主要内容如下1.字节流与字符流的区别2.文件操作3文件操作的具体实现4.实战:...
  • 类类是JAVA中一个重要的概念,可以把类理解成一个对象的抽象,这个抽象的对象包含了变量(用来描述这个对象的属性)和方法(用来描述这个对象可以干什么),类中的各个成员之间可以相互调用(static修饰的成员不能访问...
  • 关于Java中equal函数和==一些区别

    千次阅读 2015-09-14 14:57:58
    equal函数比较的到底是什么,很明显是比较的值,但是什么值?与==比较的堆中的内存地址不同,其比较的是对象的值,包括各个属性的值...java中的数据类型,可分为两: 1.基本数据类型,也称原始数据类型。byte,short
  • Java中类的加载顺序

    2021-01-21 17:09:58
     具体题目我肯定记不清,不过我们可以换个直接问法,如果A和B有静态变量,静态语句块,非静态变量,非静态语句块,构造函数,静态方法,非静态方法,同时A继承B,请问当实例化A时,内部加载顺序...
  • 我们都知道java代码在执行时候...在java类中,代码都执行顺序都会按照一定都顺序去执行: 静态代码块>构造代码块>构造函数>普通代码块 1. 静态代码块: 格式: static{ System.out.println("我是一个静...
  • java类中的初始化模块

    千次阅读 2012-02-03 15:17:30
    如果类中有多个构造函数都共享一段代码,并且各个构造函数之后不会调用其他的构造函数,那么可以将这段公共的代码放在初始化模块中。 初始化模块是用{}括起来的语句块,它位于类的声明中,...类中的初始化模块包括实
  • Java吸收了C++语言优点,也展现了其强大一面,我们能在各个地方看到其功能强大和简单易用两个特征,当然,也吸引了很多程序员注意力,所以就有人想了解Java的相关内容,今天就来讲讲Java的局部内部类的相关...
  • 【摘要】作为一门面向对象编程语言,Java吸收了C++语言的优点,也展现了...3)定义一个三角形,该与正方形一样,需要继承形状 Shape,并重写父类中的抽象方法 area()。三角形Java测试代码实现如下:pu...
  • Java吸收了C++语言优点,也展现了其强大一面,我们能在各个地方看到其功能强大和简单易用两个特征,当然,也吸引了很多程序员注意力,所以就有人想了解Java的相关内容,今天就来讲讲JDK自带记录日志类的相关...
  • 1、什么是面向对象? 百度百科是这样介绍的: 面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、...面向对象的思想已经涉及到软件开发的各个...
  • equal函数比较的到底是什么,很明显是比较的值,但是什么值?与==比较的堆中的内存地址不同,其比较的是对象的值,包括各个...java中的数据类型,可分为两:1.基本数据类型,也称原始数据类型。byte,short,char,...
  • 面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。  过程其实就是函数;对象是将函数等一些内容进行了封装。2,创建一个对象的...
  • Java是面向对象的一种语言,在Java...即使成员变量大量散布于类的各个方法定义的中间,那些成员变量仍会在调用任何方法之前得以初始化,甚至在构造函数调用之前。static构建从句class Spoon {static int i;static {i...
  • java类和对象理解

    2020-03-13 23:05:41
    java中的类和c语言中的结构体很相似,是各个数据类型的集合体。 而java中的对象是类的一个实例,比如班级是一个类,张三是该班级中的一个学生,是班级中具体的一个人。 ...方法是类中的函数。 ...
  • Java类及类成员

    2020-11-22 15:37:55
    我们在C语言,写程序往往是自顶向下设计模式,就是给一个确切方案,细分为各个细节,用函数具体写出各个细节执行过程,这是面向过程思想。 那么改为面向对象,我们思想也要随之改变。我们可以把每一个...
  • 耦合1、耦合是指两个或两个以上体系或两种运动形式间通过相互作用而彼此影响以至...耦合性是程序结构中各个模块之间相互关联度量。它取决于各个模块之间接口复杂程度、调用模块方式以及哪些信息通过接口...
  • this 的奥秘很多时候, JS 中的 this 对于咱们的初学者很容易产生困惑不解。this 的功能很强大,但需要一定付出才能慢慢理解它。对Java、PHP或其他标准语言来看,this 表示方法中当前对象的实例...

空空如也

空空如也

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

java类中的各个函数

java 订阅