Java:类和对象；方法及方法重载

类和对象

1.1 类

• 世界由什么组成？

  • 人、动物、植物...

1.2 对象和方法

• 方法：对象的操作 对象：用来描述客观事物的一个实体，由一组属性和方法构成

• 方法：对象的操作

1.2.1 创建对象和方法

创建方法

• 方法的定义方式：public [static] void main (String[] args){  }
                1.public  访问权限修饰符 方法在哪里可以访问 公开的任何地方都能访问 （必须）
                2.static  方法的修饰符  静态方法  （可有可无）
                3.void    方法的返回值类型 方法的执行结果可以通过该位置返回
                          （没有返回值，需要使用void标识符进行标识）（必须）
                          （有返回值） 根据返回值类型选定标识符 int String double
                 4.main  表示方法的名字，符合标识符命名规则，采用小驼峰命名（必须）
                 5.（String[] args）参数列表：可以实现向方法内部传递参数，形式参数（必须）
                   (int number)(int number,String info,...) (String ...)
                    () 表示没有参数
                 6.{}  方法体：编写具体业务逻辑的位置 
  
  方法定义语法：访问权限修饰符 [修饰符] 返回值类型 方法名（参数列表）{方法体}

package cn.kgc.object.day01;
​
public class Dog {
    String color;
​
    //叫
    public void bark(){
        System.out.println("叫。。。");
    }
    //跑
    public void run(){
        System.out.println("跑。。。");
    }
    //吃
    public void eat(){
        System.out.println("吃。。。");
    }
}

创建对象

• 类名 对象名 = new 类名();

• 引用对象成员：使用“.”进行以下操作

  引用类的属性：对象名.属性

  引用类的方法：对象名.方法名()

package cn.kgc.object.day01;
​
public class DogObject {
    public static void main(String[] args) {
        //通过模板创建具体的对象
        Dog dog=new Dog();
        dog.color="白色";
​
        String color= dog.color;
        System.out.println(color+"狗");
​
        dog.bark();
        dog.run();
        dog.eat();
​
    }
}

用户输入密码案例

User.java

package cn.kgc.object.day01;
​
import java.util.Scanner;
​
public class User {
    String userName;
    String password;
​
    //判定用户名和密码是否正确
    public void rootPass() {
        if ("tom".equals(userName) && "325723".equals(password)) {
            Scanner sc=new Scanner(System.in);
            System.out.print("用户输入正确，请输入修改后的密码：");
            int password= sc.nextInt();
            System.out.println("修改密码成功，新密码为："+password);
        } else if (!"tom".equals(userName)) {
            System.out.println("用户名输入错误！");
        }else if (!"325723".equals(password)) {
            System.out.println("密码输入错误！");
        }else {
            System.out.println("用户名和密码都输入错误!");
        }
    }
​
​
}

TestUser.java

package cn.kgc.object.day01;
​
import java.util.Scanner;
​
public class TestUser {
    public static void main(String[] args) {
        //创建用户对象
        User user=new User();
​
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入用户名：");
        String userName= sc.next();
        user.userName=userName;
​
        System.out.print("请输入密码：");
        String password= sc.next();
        user.password=password;
​
        user.rootPass();
​
    }
}

1.2 方法及方法重载

构造方法

构造方法

• 声明构造方法(名字必须和类名一致)：访问权限修饰符 构造方法名字（[参数列表]）

• 构造方法一旦声明，则类中不再提供默认的无参构造方法

• 成员变量在被创建时，会被初始化

• 一个类中的属性名不能重复

Car1.java

package cn.kgc.object.day01;
​
public class Car1 {
​
        //成员变量在对象创建时，会被初始化
        String brand;
        String type;
        String color;
        double price;
​
        //声明构造方法：访问权限修饰符 构造方法名字([参数列表]){ }
        //构造方法名字必须和类名保持一致
​
​
        /*构造方法一旦显式声明，则类中不再提供默认的无参构造方法*/
​
​
        public Car1(){
            System.out.println("一个Car1的对象被创建");
        }   //不生效，因为构造方法声明了
​
        public Car1(String brand,String type){
​
                System.out.println("调用car1的有参构造完成了对象的创建");
                //this指代当前对象
​
                this.brand=brand;
                this.type=type;
​
        }
        //参数列表中罗列的参数，表示形式参数，声明在方法中需要的参数类型
        public Car1(String brand,String type,String color,double price){
                this(brand,type);   //必须写在第一行
                System.out.println("调用car1的有参构造完成了对象的创建");
                //this指代当前对象
                this.brand=brand;  //等于号右边的brand就是形参列表里面的brand
                this.type=type;
                this.color=color;
                this.price=price;
​
        }
​
        public void start(){
                System.out.println("汽车发动了...");
        }
}

TestCar1.java

package cn.kgc.object.day01;
​
public class TestCar1 {
    public static void main(String[] args) {
​
        //car1()  构造方法->创建对象  属性会被初始化
        //创建类时，会默认提供一个无参构造方法
        //Car1 car1=new Car1();
        String brand="大众";
        String color="白色";
        String type="四轮";
        double price=200000;
        //调用有参构造完成的对象的创建，同时完成属性的初始化    实际参数
        Car1 car1=new Car1(brand,type,color,price);
​
        System.out.println("car1.brand="+car1.brand);
        System.out.println("car1.color="+car1.color);
        System.out.println("car1.type="+car1.type);
        System.out.println("car1.price="+car1.price);
​
        Car1 car2=new Car1("越野","红色","大轮",260000);
​
        /*car2.brand="越野";
        car2.color="红色";
        car2.type="大轮";
        car2.price=260000;*/
        System.out.println("car2.brand="+car2.brand);
        System.out.println("car2.color="+car2.color);
        System.out.println("car2.type="+car2.type);
        System.out.println("car2.price="+car2.price);
​
​
        car1.start();
​
        Car1 car3=new Car1("大众","速腾");
​
​
        /*String b="越野";
        String t="大轮";
        String c="红色";
        double p=250000;*/
​
        //调用有参构造完成对象的创建，同时完成属性的初始化
        //传递参数时，实参的名字和形参的名字可以不一致
​
    }
}
​

重载 

重载

• 一个类中不允许有两个相同名字的方法，除非两个方法满足了重载规

  • 在同一个类中；

  • 方法名相同；

  • 参数列表不同（参数个数、参数类型、参数顺序）；

  • 与访问权限修饰符和返回值类型无关

Juicer.java

package day02;
/*
* 方法的重载
* 1.一个类中不允许有两个相同名字的方法，除非两个方法满足了重载规则
* 重载:
*   在同一个类中；方法名相同；参数列表不同（参数个数、参数类型、参数顺序）；与访问权限修饰符和返回值类型无关
* */
​
/*
* 从方法重载角度，设计一个计算器类实现数据的 加减乘除 操作，将结果返回在方法之外  return
* int int
* int double
* double double
* int int int
* */
public class Juicer {
    String brand;
    String color;
//构造方法
    public Juicer(){
        System.out.println("------juicer的无参构造------");
    }
    public Juicer(String brand,String color){
        this.brand=brand;
        this.color=color;
        System.out.println("------juicer的有参构造------");
    }
//普通方法
    public void juicing(){
        System.out.println(brand+":"+color+"榨汁机开始榨果汁");
    }
    //方法的重载
    public void juicing(String fruitName){
        System.out.println(brand+":"+color+"榨汁机开始榨"+fruitName+"果汁");
    }
​
    public void juicing(int cups){
        System.out.println(brand+":"+color+"榨汁机开始榨"+"果汁"+"共"+cups+"杯");
    }
​
​
    public void juicing(int cups,String fruitName){
        System.out.println(brand+":"+color+"榨汁机开始榨"+fruitName+"果汁"+"共"+cups+"杯");
    }
​
    public void juicing(String fruitName,int cups){
        System.out.println(brand+":"+color+"榨汁机开始榨"+fruitName+"果汁"+"共"+cups+"杯");
    }
​
//    public void juicing(String fruitName,String cups){
//        System.out.println(brand+":"+color+"榨汁机开始榨"+"果汁"+"共"+cups+"杯");
//    }
​
    //方法一旦声明了返回值，则必须返回结果   返回结果类型必须保持和声明的返回结果一致
    public String juicing(String fruitName,String cups){
        String info=brand+":"+color+"榨汁机开始榨"+"果汁"+"共"+cups+"杯";
        //System.out.println(info);
        return info;  //return之后方法结束
    }
​
    //访问权限修饰符:public、默认、private、protected
​
​
​
​
}
​

TestJuicer.java

package day02;
​
public class TestJuicer {
    public static void main(String[] args) {
        /*Juicer juicer=new Juicer();
        juicer.brand="美的";
        juicer.color="白色";*/
​
        Juicer juicer=new Juicer("美的","black");
        juicer.juicing();
​
        juicer.juicing("苹果");
​
        juicer.juicing(2);
​
        juicer.juicing(2,"芒果");
​
        juicer.juicing("芒果",3);
​
        String info = juicer.juicing("芒果", "3");
​
        System.out.println("info="+info+"world");
​
    }
}