您现在的位置是：首页 > Java

当前栏目

Java的重载

JAVA 变量

2023-03-02 10:57:01 时间

*  允许同一个类中，多个同名的方法的存在，但要求形参列表不一致。

### 案例 ###

使用细节:

*  方法名必须相同
 *  形参列表：必须不同
 *  返回类型：无要求

public class Load {
        
        public static int cal(int a,int b)
        {
        
           return a+b;
        }
        public static double cal(double a, int b)
        {
        
            return a+b;
        }
        public static double cal(int a,double b)
        {
        
            return a+b;
        }
        public static int cal(int a,int b,int c)
        {
        
            return a+b+c;
        }
        public static void main(String[]args)
        {
        
              System.out.println(cal(10,20));
              System.out.println(cal(1,2,3));
              System.out.println(cal(1,1.1));
              System.out.println(cal(2.2,3));
        }
    }

public class OverloadExercise {
        
        public static void main(String[]args)
        {
        
                Methods Obj=new Methods();
                Obj.m(10);
                Obj.m(10,30);
                Obj.m("hello cmg");
        }
    }
    class Methods{
        
        public void m(int a)
        {
        
            System.out.println("方法一输出的结果"+(a*a));
        }
        public void m(int a,int b)
        {
        
            System.out.println("方法二输出的结果"+(a*b));
        }
        public void m(String s)
        {
        
            System.out.println("方法三:字符串的方法是"+s);
        }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Q9hGaIc-1631068535645)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/8f8ed640-048a-482e-b029-b5d558104c2c/Untitled.png)\]

class compare{
        
        public int max(int a,int b)
        {
        
            int c=a>b?a:b;
            return c;
        }
        public double max(double a,double b)
        {
        
            double c=a>b?a:b;
            return c;
        }
        public double max(double a,double b,double c)
        {
        
            double tmp=a>b?a:b;
            double tmp2=tmp>c?tmp:c;
            return tmp2;
        }
    }

## 可变参数 ##

Java允许同一个类中**多个同名**同功能但参数个数不统的方法，封装成一个方法

访问修饰符 返回类型 方法名（数据类型...形参名）
    {
        
    
    }

public class VarParmeter {
        
        public static void main(String[]args)
        {
        
                HMethod M=new HMethod();
                M.sum(1,2,3,4,5);
        }
    }
    class HMethod{
        
        //可以计算2个数的和，3个数的和，4，5
        //可以使用方法重载,可以使用可变参数优化
        public int sum(int ...nums)
        //int ...接收的是可变参数，类型是int，即可接收多个int
        //使用可变参数，可以当作使用来使用
        {
        
            System.out.println("接收的个数="+nums.length);
            return 0;
        }
    }

注意事项

*  可变参数的实参可以为0或任意多个
 *  可变参数的实参可以为数组
 *  可变参数的实质为数组

### 可变参数练习 ###

分别返回姓名和两门课程成绩（总分），姓名和三门课程成绩（总分），姓名和五门课程成绩（总分）。

public class HspMethod {
        
        public static void main(String[]args)
        {
        
            Hsp hm=new Hsp();
           System.out.println(hm.show("milan",90,98.5));
        }
    }
    class Hsp{
        
        public String show(String name,double ...scores)
        {
        
            double total=0;
            for(int i=0;i<scores.length;i++)
            {
        
                total+=total+scores[i];
            }
            return name+scores.length+"门课的总分为"+total;
        }
    }

## 作用域 ##

*  主要的变量就是成员变量和局部变量
 *  局部变量一般是指在成员方法中定义的变量
 *  属性如果不赋值，有默认值
 *  属性的定义语法同变量，访问修饰符 属性类型 属性名
 *  属性和局部变量可以重名，遵循就近原则
 *  在同一个作用域中，比如在同一个成员方法中，两个局部变量不能重名
 *  全局变量/属性可以加属性修饰符，局部变量不可以使用加修饰符

## 构造器 ##

[修饰符] 方法名(形参列表){
        
    		方法体
    }

*  构造器的修饰符可以默认
 *  构造器没有返回值
 *  方法名和类名字必须一样
 *  参数列表和成员方法一样的原则
 *  构造器的调用系统完成

**构造方法用于对对象的初始化**

*  一个类可以定义多个不同的构造器，即构造器的重载
 *  如果没有定义构造器，系统会生成默认无参构造器

## this关键字 ##

*  哪个对象调用，this就代表哪个对象
 *  this关键字可以用来访问类的的属性、方法、构造器
 *  用于区分当前类的属性和局部变量
 *  访问成员方法的语法：this.方法名(参数列表）
 *  访问构造器的语法：this(参数列表），**只能在构造器中使用，必须放在第一条语句**
 *  this不能再类定义的外部使用，只能在类定义的方法中使用

public class ComPa {
        
        public static void main(String[]args)
        {
        
            P b=new P("SMITH",30);
            P c=new P("MARY",30);
            System.out.println(b.com(c));
        }
    }
    class P{
        
        String name;
        int age;
        public P(String name ,int age)
        {
        
            this.name=name;
            this.age=age;
        }
        public  boolean com(P guy)
        {
        
            return this.name.equals(guy.name) && this.age == guy.age;
        }
    }

### 实例 ###

定义方法max，并返回double数组的最大值

public class Homework01 {
        
        public static void main(String[]args)
        {
        
            double [] arr={
        4,35.1,25.6,77.2,34,5,67.8,90.8};
            Max a=new Max();
            System.out.println("arr max:"+" "+a.Maximum(arr));
        }
    }
    class Max {
        
        public Double Maximum(double[] arr) {
        //包装类对象改进
            if (arr!=null&&arr.length > 0) {
        
                double max = arr[0];
                for (int i = 1; i < arr.length; i++) {
        
                    if (arr[i] > max) {
        
                        max = arr[i];
                    }
                }
                return max;
            } else {
        
                return null;
            }
    
        }
    }

*  大写的double可以返回null

### 实现查找 ###

public class Homework02 {
        
        public static void main(String[]args)
        {
        
            String [] arr={
        "hello","good","puyulong","cmg","xiao"};
            A02 fun=new A02();
            int Index=fun.Judge(arr,"jianbokai");
            if(Index!=-1)
            {
        
                System.out.println("index is location at"+" "+Index);
            }
            else{
        
                System.out.println("can not found");
            }
        }
    }
    class A02{
        
        public int Judge(String[] str,String X)
        {
        
            int index=-1;
            if(str!=null&&str.length>0)
            {
        
                for(int i=0;i<str.length;i++)
                {
        
                    if(X.equals(str[i]))
                    {
        
                        index=i;
                    }
                }
            }
            return index;
        }
    }

### 更新价格 ###

public class BOOK {
        
        public static  void main(String[]args)
        {
        
            Update fun=new Update("huo",152);
            fun.show();
            fun.upDateprice();
            fun.show();
    
        }
    }
    
    class Update{
        
        String name;
        double price;
        public Update(String name,double price)
        {
        
            this.name=name;
            this.price=price;
        }
        public void upDateprice()
        {
        
           if(price>150)
           {
        
               this.price=150;
           }
           else if(price>100&&price<150)
           {
        
               this.price=100;
           }
           else{
        
               this.price=price;
           }
        }
        public void show()
        {
        
            System.out.println("info:"+this.name+this.price);
        }
    }

### 实现数组的拷贝 ###

public class A03 {
        
        public static void main(String[]args)
        {
        
            int []arr={
        1,2,3,4,5,6};
            Fun lc=new Fun();
            int [] Ne=lc.copy(arr);
            System.out.println("after copying");
            for(int i=0;i<Ne.length;i++)
            {
        
                System.out.print(Ne[i]+" ");
            }
    
        }
    }
    class Fun{
        
        public int[] copy(int [] arr)
        {
        
            int [] co=new int [arr.length];
            for(int i=0;i<arr.length;i++)
            {
        
                co[i]=arr[i];
            }
            return co;
        }
    }

### 简单的算术器 ###

public class A06 {
        
        public static void main(String[] args)
        {
        
            cal ca=new cal(2,0);
            System.out.println("和="+ca.add());
            System.out.println("差="+ca.minus());
            System.out.println("积="+ca.mul());
            Double RES=ca.chu();
            if(RES!=null)
            {
        
                System.out.println("商="+ca.chu());
            }
    
        }
    }
    class cal{
        
        double num1;
        double num2;
        public cal(double num1,double num2)
        {
        
            this.num1=num1;
            this.num2=num2;
        }
        public double add()
        {
        
            return num2+num1;
        }
        public double minus()
        {
        
            return num1-num2;
        }
        public double mul()
        {
        
            return num1*num2;
        }
        public Double chu()
        {
        
            if(num2==0.0)
            {
        
                System.out.println("分母不可以为0");
                return null;
            }
            else{
        
                return  num1/num2;
            }
        }
    }

### 构造器的重载 ###

public class A10 {
        
        public static void main(String[]args)
        {
        
                Employee A=new Employee("huo",'m',30,"expert",5000);
                Employee B=new Employee("KKo",'m',40);
                Employee C=new Employee("expert",5000);
        }
    }
    class Employee{
        
        String name;
        char sex;//female and male 分别用f和m代替
        int age;
        String position;//职位
        int salary;
        public Employee( String name,
                char sex,
                int age
                ,String position
                ,int salary)
        {
        
            this.name=name;
            this.sex=sex;
            this.age=age;
            this.position=position;
            this.salary=salary;
        }
        public Employee(String name,char sex,int age)
        {
        
            this.name=name;
            this.sex=sex;
            this.age=age;
        }
        public Employee(String position,int salary)
        {
        
            this.position=position;
            this.salary=salary;
        }
    }

public class A13 {
        
        public static void main(String[]args)
        {
        
            CirCle c=new CirCle();
            PassObject op=new PassObject();
            op.printArea(c,5);
        }
    }
    class CirCle{
        
        double radius;
        public CirCle()
        {
        
    
        }
        public CirCle(double radius)
        {
        
            this.radius=radius;
        }
        public double findArea()
        {
        
            return Math.PI*radius*radius;
        }
        //修改当前圆的班级
        public void set(double radius)
        {
        
            this.radius=radius;
        }
    }
    class PassObject {
        
        public void printArea(CirCle c, int times)
        {
        
            double i=1;
            System.out.println("radius"+"\t"+"Area");
            for(i=1;i<=times;i++)
            {
        
                c.set(i);
                System.out.println((double)i+"\t"+c.findArea());
    
            }
        }
    }

猜你喜欢

成功实施云策略所需的十项关键技能
为什么云计算三巨头不能在混合多云博弈中获胜
建网站的步骤
2022年顶级的云计算趋势和预测
Redis持久化之AOF
新顶级域名.bond、.cyou获得工信部许可，可在中国注册备案
Redis持久化之RDB
织梦DedeCMS正式授权收费，数十万站长何去何从？
ECS使用体验之森抛
端口被占用怎么解决
查看服务器
中国电子游戏产业需要.ART的理由
中秋，和千年前的朋友一起上央视
网站被攻击怎么处理
飞天加速计划-高校学生在家实
Android小提示四
域名评估
来了！「年度最强学术答辩」看这里
分析了100万+热议数据，我们还原出新冠肺炎疫情事件脉络
河南bgp机房

zl程序教程

当前栏目

Java的重载

相关文章