Java基础学习——方法

扑克牌demo

package com.example.javaf.poker;

import java.util.Scanner;

public class MyClass {
    public static void main(String[] args) {
        //创建一张牌
        Poker p1 = new Poker();
        p1.dot = "A";
        p1.pic = "♣";

        System.out.println(p1.dot+p1.pic);
        {
            //生成一副牌
            //准备一个数组保存所有点数
            String[] dots = new String[]{
                    "2","3","4","5","6","7","8","9","10","J","Q","K","A"
            };
            //花色
            String[] pics = new String[]{"♠","♥","♣","♦"};

            //数组保存所有的扑克牌
            Poker[] pokers = new Poker[52];

            int index = 0;
            for(String dot : dots){
                for(String pic:pics){
                    //创建一张牌
                    Poker poker = new Poker();
                    poker.dot = dot;
                    poker.pic = pic;
                    pokers[index] = poker;
                    index++;
                }
            }
            for(Poker poker:pokers){
                System.out.print(poker.dot+poker.pic+" ");
            }
        }
    }
}

println 自动换行

print 不换行

java的数组

数组的定义

        {
            int num[] = new int[30];
            num[0] = 20;
            num[1] = 30;
            //获取数组个数
            System.out.println("数组个数：" + num.length);
            //静态数组
            String name[] = new String[]{"jack", "merry", "rose"};
            //常用定义
            String[] titles = new String[]{"热点", "体育", "新闻"};
            //如何遍历一个数组
            for (int i = 0; i < titles.length; i++) {
                System.out.println(titles);
            }
            //增强for循环
            for (String temp : titles) {
                System.out.println(temp);
            }
        }

image.png

方法定义

一.属性/方法

类->内部类
接口
静态代码块
Java是面向对象的语言 一切皆对象 类，Java里面方法不能独自存在，只能在类里面声明
类方法 = 静态方法
对象方法 = 实例方法

二.对象方法和实例方法区别

定义的区别
静态方法 使用static修饰
意义的区别
静态方法依附于这个类本身，比实例方法优先被加载
当这个类被加载到内存中时，这个方法就被加载了，而此时对象还不存在
所以只能用这个类来调用
对象方法依附于对象，必须创建这个类的一个对象，用对象来调用
static可以修饰以下内容
变量 静态变量
方法 静态方法
类（内部类）静态内部类

参数是值传递

java参数传递机制
值传递(传递的是一份拷贝)

可变参数

“...” 数组

方法承载与构造方法

方法重载：同一个类里面 方法名相同 参数不同
方法的承载和返回值 修饰符 没有关系
构造方法：构造方法是一种特殊的方法，它是一个与类同名的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。

1. 构造方法分为两种：无参构造方法 有参构造方法
2. 构造方法的作用
   解决两个问题
   让代码更简洁
   在数据使用时能够保证有数据

public class Person {
    //定义一个没有参数的实例方法
    //public protected private
    public void eat(int a){
        a++;
    }
    public void test3(Car car){
        car.wheelcount = 4;
    }

    public void work(String tool,String dest){

    }
    public String test(){
        return "result";
    }
    public static void test2(){

    }
    public void test4(String ... args){
        for (int i = 0;i < args.length;i++){
            System.out.println(args[i]);
        }
    }
}

public class Car {
    public int wheelcount;
    public int engine;
    public int seat;
    public Car(){

    }
    public Car(int count){
        wheelcount = count;
    }
    public Car(int count, int cEngine, int cSeat){
        wheelcount = count;
        engine = cEngine;
        seat = cSeat;
    }

    public void test(){
        System.out.println("engine count:"+engine);
    }
}

public class MyClass {
    public static void main(String[] args){
 //       Person p = new Person();
  //      p.eat();
  //      p.work("榔头","工地");
  //      String result = new p.test();

  //      Person.test2();
        {
            int a = 10;
            Person p = new Person();
            p.eat(a);
            System.out.println("a=" + a);
        }
        {
            Car bz = new Car();
            bz.wheelcount = 8;

            Person p = new Person();
            p.test3(bz);

            System.out.println("wheel count is "+bz.wheelcount);
        }
        {
            Person p = new Person();
            p.test4("jack","rose","merry");
        }
        {
            Car c1 = new Car();
            c1.wheelcount = 4;
            c1.engine = 2;
            c1.seat = 7;
            Car c2 = new Car(4,2,7);
        }
        {
            Car c1 = new Car();
            c1.engine = 3;
            c1.test();

            Car c2 = new Car(3,2,7);
            c2.test();
        }
    }
}

image.png