java_方法_类与对象-CSDN博客

本文链接：https://blog.csdn.net/qq_67764134/article/details/129697236

1.方法

1.说明

我们可以使用方法来完成某一个功能，用的时候直接调用方法。

2.代码

public class fangFa {
    /**
     * 方法使用
     * 定义了一个方法“fang”
     * 只是定义了一个方法，并没有进行调用
     */
    public static void fang(){
        System.out.println("abc");
        System.out.println("def");
        System.out.println("lmn");
    }

    /**
     * 写一个数数的方法
     */
    public static void coutn(){
        for(int i=0;i<10;i++){
            System.out.print(i+" ");
        }
        System.out.println("\n完成");
    }

    /**
     * 方法返回值
     * 方法返回值的时候要在函数名前面声明
     * 需要写出返回值的类型
     */
    public static String buy1(){
        System.out.println("买一包烟");
        return "中华香烟";
    }

    /**
     *方法传参
     * 在函数名后面括号里写入参数
     */
    public static void buy2(String goods,int price){
        System.out.println("需要买:"+goods+"  价格:"+price);
    }

    /**
     *方法的重载
     * 可以省去起名字的烦恼
     * 可以传入不同的参数
     * 参数不同时他会自动寻找对应的函数
     */
    public static void add(int a,int b){
        System.out.print("int计算:");
        System.out.println(a+b);
    }
    public static void add(double a,double b){
        System.out.print("double计算:");
        System.out.println(a+b);
    }

    public static void add(double a,double b,int c,int  d){
        System.out.print("四个数计算:");
        System.out.println("a+b="+(a+b)+"     c+d="+(c+d));
    }
    //主函数，程序的入口
    public static void main(String[] args) {
        //调用方法
        fang();//调用“fang”这个方法
        coutn();
        String bu=buy1();//进行接受返回值
        System.out.println(bu);
        buy2("肉",50);
        add(3,4);
        add(1.5,4.2);
        add(1.2,2.5,3,4);
    }
}

3.解释

1.方法规范

public static 返回值类型 方法名(参数类型 参数){
	语句
	return 返回值
}

返回值与返回类型要匹配，当不返回值时可以将返回值类型写为void，不写return。
当不传参数时括号里面不写，当传入多个参数时可用逗号分开。

2.方法重载

public static void add(int a,int b){
        System.out.print("int计算:");
        System.out.println(a+b);
    }
public static void add(double a,double b){
    System.out.print("double计算:");
    System.out.println(a+b);
}

方法的重载
当传入的参数类型不同或个数不同时，我们可以使用方法的重载，这样可以减少命名带来的烦恼。
当我们调用方法传入参数时，会自动寻找对应的方法。

2.类与对象

1.说明

我们可以对某一个功能进行封装，进行打包，定义出一个类。
当我们使用这个类的时候可以调用这个类定义出一个对象，然后通过这个对象来实现对应的功能。

2.代码

class carDx{
    String yanse;//颜色
    int sudu;//速度
    int zuowei;//座位
    //成员方法
    public void run(){
        //this相当于carDxs方法中的对象c
        System.out.println("run方法中:\n\t车速度:"+this.sudu);
        System.out.println("\t车正常，可以上路");
    }
    public void fly(){
        System.out.println("fly方法中:\n"+"\t车颜色:"+this.yanse);
        System.out.println("\t经过改造，车可以飞");
    }
    /**
     * this用法
     * 在调用方法时,默认讲参数传给方法，在方法中可以使用this接受参数
     *在查找变量的时候先看自己方法里面有没有，如果没有再在类中查找
     */
    public void swim(String yanse){
        System.out.println("swim方法中:");
        System.out.println("\t在"+yanse+"的海里面");
        System.out.println("\t车颜色:"+this.yanse);
        System.out.println("\t车座位:"+zuowei);
    }
}
public class LeiyuDuixiang{
    public static void carDxs(){
        //创建对象，这种变量称为引用
        carDx c =new carDx();//carDx中的属性就是类中定义好的成员变量
        c.yanse="白色";
        c.sudu=120;
        c.zuowei=5;
        c.run();//在调用方法时,默认讲参数传给方法，在方法中可以使用this接受参数
        c.fly();
        c.swim("蓝色");
        System.out.println("carDxs方法中:\n\t车座位:"+c.zuowei);
        System.out.println("\t"+c.yanse+" "+c.sudu+" "+c.zuowei);
    }
    public static void main(String[] args) {
        carDxs();
    }
}

3.解释

1.类的规范

class carDx{
    成员变量类型 成员变量名
    
    public 返回值类型 成员方法名(参数类型 参数){
        语句
        return 返回值。
    }
}

类中由成员变量和成员方法构成。

2.this的使用

public void swim(String yanse){
	System.out.println("swim方法中:");
	System.out.println("\t在"+yanse+"的海里面");
	System.out.println("\t车颜色:"+this.yanse);
	System.out.println("\t车座位:"+zuowei);
}

一个类可以定义多个对象，当我们要在类中使用某个对象的成员变量，我们可以使用this。
在调用方法时,默认讲参数传给方法，在方法中可以使用this接受参数
在查找变量的时候先看自己方法里面有没有，如果没有再在类中查找

3.调用类定义对象

carDx c =new carDx()

c.yanse="白色";

c.swim("蓝色")

第一行：通过carDx定义出一个对象c
第二行：对成员变量进行赋值
第三行：调用成员方法

3.构造方法

1.说明

当我们在定义对象时就需要往类中传入参数，我们可以使用构造方法来为类传入参数。

2.代码

class carGz{
    /**
     * 构造方法
     * 在定义对象的时候这个类就会自动调用构造方法
     * 当我们不写构造方法时java会给出一个无参数的构造方法
     * 当我们定义了构造方法后系统就不会给我们默认的构造方法
     * 在静态方法和静态块中不能使用this
     */
    String yanse;
    int sudu;
    int zuowei=5;
    public carGz(String yanse, int sudu) {
        this.yanse=yanse;
        this.sudu=sudu;
    }
    public void run(){
        System.out.println("车正常，可以跑");
    }
}

class daxiaGz{
    /**
     * 构造方法重载
     * 构造方法也是方法，可以进行重载
     * 当传入不同的参数时，java会自动寻找对应的构造方法
     */
    String name;
    String waihao;
    int age;
    String bangpai;
    public daxiaGz(String name,int age,String bangpai){
        this.name=name;
        this.age=age;
        this.bangpai=bangpai;
    }
    public daxiaGz(String name,String waihao,int age,String bangpai){
//      方法一
//        this.name=name;
//        this.waihao=waihao;
//        this.bangpai=bangpai;
//        this.age=age;
//      方法二
        this(name,age,bangpai);//使用this可以调用当前类中其他的构造方法
        this.waihao=waihao;
    }
    public void information(){
        System.out.println("姓名:"+this.name+"\t外号:"+this.waihao+"\t年龄:"+this.age+"\t帮派:"+this.bangpai);
    }
}
class personGz{
    /**
     * static用法
     * 静态的内容在内存中保留一份
     * 在各个对象中进行共享
     * 属于类而不属于对象
     * 静态优先于对象产生
     */
    String name;
    static String country="大清";
    String address;
    public personGz(String name,String address){
        this.name=name;
        this.address=address;
    }
    public void inform(){
        System.out.println("姓名:"+this.name+"\t国籍:"+ country+"" + "\t地址:"+this.address);
    }
}
class youxianGz{
    {
        System.out.println("通用构造器");
    }
    static {
        System.out.println("静态构造器");
    }
    /**
     * 当定义对象时
     * 先执行静态构造器
     * 然后执行通用构造器
     * 最后执行构造函数
     */
    public youxianGz(){
        System.out.println("构造函数");
    }
}
public class GouzaoFangfa {
    public static void carGzs(){
        carGz c1=new carGz("白色",150);
        System.out.println(c1.zuowei);
        c1.run();
        carGz c2=new carGz("黑色",120);
        System.out.println(c2.zuowei);
        c2.run();
    }
    public static void daxiaGzs(){
        daxiaGz zhangsan=new daxiaGz("张三",21,"三帮");
        zhangsan.information();
        daxiaGz lisi=new daxiaGz("李四","小四",23,"四帮");
        lisi.information();
    }
    public static void personGzs(){
        personGz p1=new personGz("张三","八大胡同");
        p1.inform();
        personGz p2=new personGz("李四","朝阳门");
        p2.inform();
        personGz.country ="民国";//通过类调用静态变量
        p1.inform();
        p2.inform();
    }
    public static void youxianGzs(){
        new youxianGz();
    }
    
    public static void main(String[] args) {
        System.out.println("---------------------------------------------------");
        carGzs();
        System.out.println("---------------------------------------------------");
        daxiaGzs();
        System.out.println("---------------------------------------------------");
        personGzs();
        System.out.println("---------------------------------------------------");
        youxianGzs();
    }
}

3.解释

1.构造函数规范

public carGz(String yanse, int sudu) {
    this.yanse=yanse;
    this.sudu=sudu;
}


public 类名(参数类型 参数){
	this.成员变量 = 参数
}

当我们调用类时，系统会自动调用构造方法，当我们没有定义构造方法时系统会自动生成一个空的构造方法，当我们定义了构造方法时，系统就不会再定义构造方法

2.构造方法重载

 public 类名(参数1，参数2，参数3) {
 	语句
 }
 public 类名(参数4，参数5，参数6，参数7) {
 	语句
 	this(参数1，参数2，参数3)
 }

构造方法也是一种方法，也可以进行重载，当传入不同的参数时，java会自动寻找对应的构造方法。
当使用this时，系统会调用当前类中其他的构造方法。

3.static用法

static 静态
静态内容属于类而不属于对象。静态的东西可以在各个类中进行共享，静态优先于对象产生。

4.构造器

class 类名{
        System.out.println("通用构造器");
    }
    
    static {
        System.out.println("静态构造器");
    }
   
    public 类名(){
        System.out.println("构造函数");
    }
}