JAVA对象/字符串方法重载（java 字符串对象）

25-04-03 5

对于想了解JAVA对象/字符串方法重载的读者，本文将是一篇不可错过的文章，我们将详细介绍java字符串对象，并且为您提供关于Java--构造函数&this&方法重写和方法重载的区别、Java——对象类

对于想了解JAVA对象/字符串方法重载的读者，本文将是一篇不可错过的文章，我们将详细介绍java 字符串对象，并且为您提供关于Java -- 构造函数 & this & 方法重写和方法重载的区别、Java ——对象类方法重载构造方法封装内部类、Java 之面向对象 --3.2.2 方法重载、JAVA 基础 / 第二十三课：类和对象 / 什么是JAVA中的方法重载？构造方法?的有价值信息。

本文目录一览：

JAVA对象/字符串方法重载（java 字符串对象）
Java -- 构造函数 & this & 方法重写和方法重载的区别
Java ——对象类方法重载构造方法封装内部类
Java 之面向对象 --3.2.2 方法重载
JAVA 基础 / 第二十三课：类和对象 / 什么是JAVA中的方法重载？构造方法?

JAVA对象/字符串方法重载（java 字符串对象）

出于好奇，我尝试了这个例子。

public class Class1 {    public void method(Object obj){        System.out.println("Object");    }    public void method(String str){        System.out.println("String");    }    public static void main(String... arg){        new Class1().method(null);    }}

输出为“字符串”。我想知道JVM决定在什么基础上调用以String作为参数而不是Object的方法。

答案1

小编典典

只要可以将多个重载方法应用于参数列表，就会使用最具体的方法。

在这种情况下，传递时都可以调用这两种方法null，因为“空类型”既可以分配给也可以分配Object给String。采取的方法String更加具体，因此将被选择。

Java -- 构造函数 & this & 方法重写和方法重载的区别

JAVA：

今天总结一下构造方法、关键字、方法重载和方法重写的异同

一、构造方法（构造函数）
1、构造方法的作用：
一是创建对象时调用构造方法创建对象，二是可以初始化多个属性

【学生类创建一个学生对象 stu：Student stu = new Student () 这里调用的是无参构造函数。】

2、构造函数的结构及注意事项：
1、结构：【public 类名（[参数类型 1 参数名 1, 参数类型 2 参数名 2.....]）】
2、参数可无
3、一般在创建一个类的时候，如果创建的类没有构造函数程序会自动创建一个默认的无参构造函数，当你在类中已经写有构造函数，那么默认无参构造函数将会被覆盖，也就是不存在。

二、关键字 this:
this 主要有三个作用：
1、在本类中作为对象调用属性，在属性名与参数名相同时，需要用 this 来调用属性给属性赋值，否则无法赋值。
2、调用构造函数
3、可以返回本类对象（目前用途我还不是很清楚...）

例子：创建一个学生类

 1 package object1;
 2 
 3 public class Student {
 4     //属性 （四种访问权限的属性）
 5     public String name;
 6     protected String sno;
 7     int score;
 8     private int age;
 9     
10     //注意点：1不能写返回类型  2 方法名为类名。 结构为 public 类名([参数]){};
11     public Student(String name,String sno) {
12         //初始化属性
13         this.name = name;
14         this.sno = sno;
15     }
16     /*
17      * 方法重载(构造方法也可以重载)  1方法名相同  2返回类型、参数类型/个数不能全部相同
18      */
19     public Student(){
20         //调用另一个构造函数（方法）
21         this("缺省","20190123");
22      /* 初始化属性
23         name = "B";  */
24     }
25     public void Study()
26     {
27         System.out.println(name + "正在学习...");
28     }
29     protected void Study(String sno,String name)
30     {
31         
32         System.out.println(name + "的学号时是："+sno);
33     }
34     public Student object() {
35         return this;
36     }
37 }

主类

 1 package object1;
 2 
 3 public class Main {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         Student stu1 = new Student("abc","123");
 8         Student stu3;
 9         System.out.println("用无参构造函数生成对象stu1: \n");
10         stu1.Study();
11         stu1.Study("201901", "abc");
12         
13         System.out.println();
14         Student stu2 = new Student("ABC","20190123");
15         System.out.println("用有参构造函数生成对象stu2: \n");
16         stu2.Study();
17         stu2.Study("201923", "A");
18         
19      /*   //对属性的使用
20         stu1.name = "B";
21         stu1.sno = "90120123";
22         stu1.score = 100;
23         //报错,因为age是私有属性，不能被其他类直接调用
24         stu1.age = 18;  */
25         stu3 = stu1.object();
26         stu3.Study();
27         stu3.name = "bvjkbsd";
28         System.out.println(stu3.name); 
29     }
30 
31 }

View Code

运行结果

用无参构造函数生成对象stu1: 
abc正在学习...
abc的学号时是：201901

用有参构造函数生成对象stu2: 
ABC正在学习...
A的学号时是：201923

stu3: 
abc正在学习...
bvjkbsd

三、方法重载和方法重写
两个都是原方法已经无法满足需求了而重写或者重载，但两者依旧是有区别的。两者最明显的区别就是方法重载是在同一个类中写的，方法重写是在子类中对父类的方法进行重写，也就
是不同类中，其次方法重载是要求方法名相同，返回类型、参数类型、参数个数至少要有一个不一样，而方法重写要求方法名，返回类型、参数类型、参数个数全部相同。最后是方法重
写的访问权限只能扩大（权限大小：public > protected > 缺省 > private），而方法重载对权限无要求。

Java ——对象类方法重载构造方法封装内部类

本节重点思维导图

快捷键

生成代码：alt+shift+s
提取变量：alt+shift+L
快速复制行：alt+ctrl+向上或向下的箭头
删除行：ctrl+d

类：对同一种事物共同属性和行为的抽象

对象：根据类创建出来的具体的实物

方法重载

在同一个类中提供多个同名不同参的方法。

重载要求：方法名称相同，但参数的【 类型不同 or 参数的个数不同 or 参数的顺序不同】

public class Demo {
    public void fun1() {
    }
    public void fun1(int a) {
    }
    public void fun1(String c) {
    }
    public void fun1(int c, int d) {
    }
    public void fun1(String c, int d) {
    }
    public void fun1(int d, String c) {
    }
}
对于重载，系统是根据     实参    确定最终调用的哪一个方法的

public class Teacher {
    int id;
    String name;
    String major;

    public Teacher() {
        System.out.println("默认构造方法");
    }

    public Teacher(int id) {
        System.out.println("Teacher(int id)");
    }

    public Teacher(int id, String name) {
        this.id = id;
        this.name = name;
        System.out.println("Teacher(int id,String name)");
    }

    public void shangKe() {
        System.out.println("shangKe");
    }

    public void piGaiZuoYe() {
        System.out.println("pi gai zuo ye");
    }
}

注意：this指的是new出来的空间。

封装

访问控制修饰符

private：私有的，只能在当前类中使用，其它任何类都不能使用
public：公共的，谁（任何地方的任何类）都可以使用

public class Person {
    private int age;
    private String gender;
    private float height;

    public void setAge(int age) {
        if (age < 0 || age > 125) {
            System.out.println("age input error");
            return;//从方法中返回
        }
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }
}

内部类

将一个类的定义放在另一个类的定义内部，这就是内部类。

如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相当于其中的某个器官之一，例如心脏：它也有自己的属性和行为（血液、跳动）

显然，此处不能单方面用属性或者方法表示一个心脏，而需要一个类，而心脏又在人体当中，正如同是内部类在外部类当中。

1）不用内部类：

public class Person {
    private int blood;
    private Heart heart;
}

public class Heart {
    private int blood;
    public void test() {
        System.out.println(blood);
    }
}

2）使用内部类：

public class Person {
    private int blood;
    public class Heart {
        public void test() {
            System.out.println(blood);
        }
    }

    public class Brain {
        public void test() {
            System.out.println(blood);
        }
    }
}

内部类优点和缺点：

优点：可访问外部类私有属性（心脏可访问身体的血液，而不是外部抽血）。
缺点：破坏原有类的程序结构（属性、构造方法、普通方法、内部类）。

应用举例：

//外部类
class Out {
    private int age = 12;
     
    //内部类
    class In {
        public void print() {
            System.out.println(age);
        }
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.print();
        //或者采用下种方式访问
        /*
        Out out = new Out();
        Out.In in = out.new In();
        in.print();
        */
    }
}

运行结果：12

从上面的例子不难看出，内部类其实严重破坏了良好的代码结构，但为什么还要使用内部类呢？

因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点。

如同心脏可以直接访问身体的血液，而不是通过医生来抽血。

程序编译过后会产生两个 .class 文件，分别是 Out.class 和 Out$In.class。

其中 $ 代表了上面程序中 Out.In 中的那个。

Out.In in = new Out().new In() 可以用来生成内部类的对象，这种方法存在两个小知识点需要注意：

1.开头的 Out 是为了标明需要生成的内部类对象在哪个外部类当中。
2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量。

java 中的内部类总结

Java 内部类详解

额外补充：

1.java因强制要求类名（唯一的public类）和文件名统一，因此在引用其它类时无需显式声明。在编译时，编译器会根据类名去寻找同名文件。

2.package 的作用是防止名字相同的类产生冲突。Java 编译器在编译时，直接根据 package 指定的信息直接将生成的 class 文件生成到对应目录下。如 package aaa.bbb.ccc 编译器就将该 .java 文件下的各个类生成到 ./aaa/bbb/ccc/ 这个目录。

import 是为了简化使用 package 之后的实例化的代码。假设 ./aaa/bbb/ccc/ 下的 A 类，假如没有 import，实例化A类为：new aaa.bbb.ccc.A()，使用 import aaa.bbb.ccc.A 后，就可以直接使用 new A() 了，也就是编译器匹配并扩展了 aaa.bbb.ccc. 这串字符串。

为什么JAVA文件中只能含有一个Public类?

java 程序是从一个 public 类的 main 函数开始执行的，(其实是main线程)，就像 C 程序是从 main() 函数开始执行一样。只能有一个 public 类是为了给类装载器提供方便。一个 public 类只能定义在以它的类名为文件名的文件中。

每个编译单元(文件)都只有一个 public 类。因为每个编译单元都只能有一个公共接口，用 public 类来表现。该接口可以按照要求包含众多的支持包访问权限的类。如果有一个以上的 public 类，编译器就会报错。并且 public类的名称必须与文件名相同(严格区分大小写)。当然一个编译单元内也可以没有 public 类

成员变量和类变量的区别

由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。

成员变量和类变量的区别：

1、两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象的回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

3、别名不同

成员变量也称为实例变量。

静态变量也称为类变量。

4、数据存储位置不同

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

static 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

3、静态随着类的加载而加载。而且优先于对象存在。

弊端：

1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

2、静态方法只能访问静态成员，不可以访问非静态成员。

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

3、静态方法中不能使用this，super关键字。

因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？

成员分两种：

1、成员变量。（数据共享时静态化）

该成员变量的数据是否是所有对象都一样：

如果是，那么该变量需要被静态修饰，因为是共享的数据。

如果不是，那么就说这是对象的特有数据，要存储到对象中。

2、成员函数。（方法中没有调用特有数据时就定义成静态）

如果判断成员函数是否需要被静态修饰呢？

只要参考，该函数内是否访问了对象中的特有数据：

如果有访问特有数据，那方法不能被静态修饰。

如果没有访问过特有数据，那么这个方法需要被静态修饰。

成员变量和静态变量的区别：

1、成员变量所属于对象。所以也称为实例变量。

静态变量所属于类。所以也称为类变量。

2、成员变量存在于堆内存中。

静态变量存在于方法区中。

3、成员变量随着对象创建而存在。随着对象被回收而消失。

静态变量随着类的加载而存在。随着类的消失而消失。

4、成员变量只能被对象所调用。

静态变量可以被对象调用，也可以被类名调用。

所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

6.创建对象时，new关键字的作用：

8.java中this 和 super的用法总结

this 指向对象本身的指针，形参与成员名字重名，用 this 来区分。
super 超（父）类对象的一个指针。

Java 之面向对象 --3.2.2 方法重载

// 方法重载
// 同一个类中可以定义多个同名的方法，方法的参数不同
// 参数不同的情况：
//1. 参数的数目不同
//2. 参数的类型不同
//3. 参数的顺序不同

public class OverLoad{

   // 成员变量
   int [] arr = {5,2,8,7,1,4,9}; // 数组可以作为成员变量

   // 成员方法
   public void print(){
       for(int i=0;i<arr.length;i++){
           System.out.print(arr[i]+"\t");
       }
       System.out.println();
   }

   // 下面属于重复定义的方法：访问修饰符和返回值类型不能区分不同的方法
   /*
   private int print(){
       return 100;
   }
   */

   public void print(int a){
       for(int i=0;i<=a;i++){
           System.out.print(arr[i]+"\t");
       }
       System.out.println();
   }


   public void print(int a,int b){
       for(int i=a;i<=b;i++){
           System.out.print(arr[i]+"\t");
       }
       System.out.println();
   }

   // 下面是重复定义的方法
   /*
   public void print(int b,int a){

   }
   */

   public void print(int a,boolean flag){
       if(flag){
           for(int i=0;i<=a;i++){
               System.out.print(arr[i]+"\t");
           }
           System.out.println();
       }else{
           for(int i=a;i<arr.length;i++){
               System.out.print(arr[i]+"\t");
           }
           System.out.println();
       }


   }

   public void print(boolean flag,int a){

   }

   public void print(int a,int b, int c){
       for(int i=a;i<=b;i+=c){
           System.out.print(arr[i]+"\t");
       }
       System.out.println();
   }

   public static void main(String args[]){

       OverLoad ol = new OverLoad();
       // 方法调用时，根据传入的实际参数，匹配到唯一的方法执行
       ol.print();
       ol.print(3);
       ol.print(2,5);
       ol.print(2,false);
       ol.print(1,6,2);

   }

}

JAVA 基础 / 第二十三课：类和对象 / 什么是JAVA中的方法重载？构造方法?

2018-03-14

一、方法的重载指的是方法名一样，但是参数类型不一样：

1、attack方法的重载：

有一种英雄，叫做物理攻击英雄 ADHero，为ADHero 提供三种方法；

public void attack()
public void attack(Hero h1)
public void attack(Hero h1, Hero h2)

方法名是一样的，但是参数类型不一样
在调用方法attack的时候，会根据传递的参数类型以及数量，自动调用对应的方法

public class ADHero extends Hero {
    public void attack() {
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    } 
    public void attack(Hero h1) {
        System.out.println(name + "对" + h1.name + "进行了一次攻击 ");
    } 
    public void attack(Hero h1, Hero h2) {
        System.out.println(name + "同时对" + h1.name + "和" + h2.name + "进行了攻击 ");
    } 
    public static void main(String[] args) {
        ADHero bh = new ADHero();
        bh.name = "赏金猎人";
        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫"; 
        bh.attack(h1);
        bh.attack(h1, h2);
    }
}

2、可变数量的参数：

如果要攻击更多的英雄，就需要设计更多的方法，这样类会显得很累赘，像这样：

public void attack(Hero h1)
public void attack(Hero h1,Hero h2)
public void attack(Hero h1,Hero h2,Hero 3)

这时，可以采用可变数量的参数，只需要设计一个方法

public void attack(Hero ...heros)

即可代表上述所有的方法了，在方法里，使用操作数组的方式处理参数heros即可

public class ADHero extends Hero { 
    public void attack() {
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    }
    // 可变数量的参数
    public void attack(Hero... heros) {
        for (int i = 0; i < heros.length; i++) {
            System.out.println(name + " 攻击了 " + heros[i].name); 
        }
    } 
    public static void main(String[] args) {
        ADHero bh = new ADHero();
        bh.name = "赏金猎人"; 
        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫"; 
        bh.attack(h1);
        bh.attack(h1, h2);
 
    }
}

二、通过一个类创建一个对象，这个过程叫做实例化，实例化是通过调用构造方法(又叫做构造器)实现的：

1、什么是构造方法：

方法名和类名一样（包括大小写）没有返回类型，实例化一个对象的时候，必然调用构造方法

public class Hero { 
    String name; 
    float hp; 
    float armor; 
    int moveSpeed; 
    // 方法名和类名一样（包括大小写）
    // 没有返回类型
    public Hero() {
        System.out.println("实例化一个对象的时候，必然调用构造方法");
    }     
    public static void main(String[] args) {
        //实例化一个对象的时候，必然调用构造方法
        Hero h = new Hero();
    } 
}

2、隐式的构造方法：

Hero类的构造方法是：

public Hero(){ }

这个无参的构造方法，如果不写，就会默认提供一个

public class Hero {     
    String name; //姓名     
    float hp; //血量     
    float armor; //护甲     
    int moveSpeed; //移动速度    
    //这个无参的构造方法，如果不写，
    //就会默认提供一个无参的构造方法
    //  public Hero(){ 
    //      System.out.println("调用Hero的构造方法");
    //  }
 
    public static void main(String[] args) {
        Hero garen =  new Hero();
        garen.name = "盖伦";
        garen.hp = 616.28f;
        garen.armor = 27.536f;
        garen.moveSpeed = 350;
         
        Hero teemo =  new Hero();
        teemo.name = "提莫";
        teemo.hp = 383f;
        teemo.armor = 14f;
        teemo.moveSpeed = 330;
    }       
}

3、如果提供了一个有参的构造方法：

一旦提供了一个有参的构造方法，同时又没有显式的提供一个无参的构造方法
那么默认的无参的构造方法，就“木有了“。

public class Hero {      
    String name; //姓名      
    float hp; //血量      
    float armor; //护甲      
    int moveSpeed; //移动速度      
    //有参的构造方法
    //默认的无参的构造方法就失效了
    public Hero(String heroname){ 
        name = heroname;
    }      
    public static void main(String[] args) {
        Hero garen =  new Hero("盖伦"); 
          
        Hero teemo =  new Hero(); //无参的构造方法“木有了”
    }        
}

4、构造方法的重载：

和普通方法一样，构造方法也可以重载。

public class Hero {       
    String name; //姓名       
    float hp; //血量       
    float armor; //护甲       
    int moveSpeed; //移动速度       
    //带一个参数的构造方法
    public Hero(String heroname){ 
        name = heroname;
    }    
    //带两个参数的构造方法
    public Hero(String heroname,float herohp){ 
        name = heroname;
        hp = herohp;
    }       
    public static void main(String[] args) {
        Hero garen =  new Hero("盖伦"); 
        Hero teemo =  new Hero("提莫",383);
    }    
}

今天的关于JAVA对象/字符串方法重载和java 字符串对象的分享已经结束，谢谢您的关注，如果想了解更多关于Java -- 构造函数 & this & 方法重写和方法重载的区别、Java ——对象类方法重载构造方法封装内部类、Java 之面向对象 --3.2.2 方法重载、JAVA 基础 / 第二十三课：类和对象 / 什么是JAVA中的方法重载？构造方法?的相关知识，请在本站进行查询。

本文标签：