Java对象

一、java中的对象

        处理当前类与其他类之间的关系，需要使用对象，什么是对象呢？对象是通过java类创建的用来在其他类中调用创建对象的java类中的变量和方法的具体元素。

public class Student {
    //实例变量
    public  String name="zhangsan";
    //实例方法
    public  void  sayHello(){
        System.out.println("Student类中的实例方法");
    }
}

public class Person {
    public  void  personShiLi(){
        System.out.println("Person类中的实例方法");
        //如果要在person类的方法中使用Student类的变量和方法，
        //需要创建Student类对象来调用Student类中的变量和方法
        //通过new这个关键字使用java类构造方法创建类的对象
        //为了方便使用这个对象，可以定义该类的变量来保存对象
        Student student=new Student();
        System.out.println("调用Student类的实例变量name=="+student.name);
        //调用Student类的方法
        student.sayHello();
    }
}

对象是由类创建的，没有类就没有对象，对象可以在其他类中访问本类中的元素。

二、创建对象

        条件：1.要有JAVA类

                   2.通过new关键字使用java类构造方法来创建当前类的对象

三、创建对象的作用

        在其他类的方法中调用创建对象的这个类中的变量/方法

四、在不同类中使用对象调用实例变量和静态成员变量

public class Cars {
    //定义一个实例变量
    public int longth = 1000;
    //定义一个静态成员变量
    static int age =29;

}

public class Flys {
    //创建一个Cars对象
    public Cars ca = new Cars();
    //赋值给Flys类中的实例变量，用类变量.Cars中实例变量名称
    public int wid = ca.longth;
    //使用Cars类中的静态成员变量
    public  static int age = Cars.age;
}

public class TestMain {
    public static void main(String[] args) {
        //创建一个Flys类的对象
        Flys fl=new Flys();
        System.out.println(fl.wid+"-----------"+Flys.age);
    }
}

五、不同类中使用对象调用构造方法、实例方法、静态方法

public class Cars {
    //定义一个实例变量
    public int longth = 1000;
    //定义一个静态成员变量
    static int age =29;
    //定义一个实例方法
    public void shiLi(){
        System.out.println("我是Cars类中的实例方法，汽车长度为："+longth);
    }
    //定义一个构造方法
    public Cars(){
        System.out.println("我是Cars类中的构造方法");
    }
    //定义一个静态方法
    public static void staticCars(){
        System.out.println("我是Cars类中的静态方法");
    }

}

public class Flys {
   // Flys类的构造方法
    public Flys(){
        System.out.println("Flys类中的---构造方法---调用Cars类中的元素");
        //调用Cars类中的实例变量,通过变对象调用
        Cars ca1 = new Cars();
        System.out.println("Flys类中的构造方法，调用Cars类中的实例变量："+ca1.longth);
        //调用Cars类中的静态变量，即可以通过变量，又可以通过类名调用
        System.out.println("Flys类中的构造方法，调用Cars类中的静态成员变量："+ca1.age);
        System.out.println("Flys类中的构造方法，调用Cars类中的静态成员变量："+Cars.age);
        //调用Cars类中的实例方法,只能通过对象调用
        ca1.shiLi();
        //调用Cars类中的静态方法，即可以通过对象调用，也可以通过类名调用
        ca1.staticCars();
        Cars.staticCars();
    }
    //Flys类的实例方法
    public void shiLiFlys(){
        System.out.println("Flys类中的---实例方法---调用Cars类中的元素");
        //创建一个Cars类的对象
        Cars ca2 = new Cars();
        //用对象调用Cars类中的实例变量
        System.out.println("Flys类中的实例方法，调用Cars类的实例变量："+ca2.longth);
        //用对象调用Cars类中的静态成员变量
        System.out.println("Flys类中的实例方法，调用Cars类的静态成员变量："+ca2.age);
        //用类名调用Cars类中的静态成员变量
        System.out.println("Flys类中的实例方法，调用Cars类的静态成员变量："+Cars.age);
        //用对象调用Cars类中的实例方法
        ca2.shiLi();
        //用对象调用Cars类中的静态方法
        ca2.staticCars();
        //用类名调用Cars类中的静态方法
        Cars.staticCars();

    }
    //Flys类的静态方法
    public static  void staticFlys(){
        System.out.println("Flys类中的---静态方法---调用Cars类中的元素");
        //调用Cars类中的实例变量,通过变对象调用
        Cars ca3 = new Cars();
        System.out.println("Flys类中的静态方法，调用Cars类中的实例变量："+ca3.longth);
        //调用Cars类中的静态变量，即可以通过变量，又可以通过类名调用
        System.out.println("Flys类中的静态方法，调用Cars类中的静态成员变量："+ca3.age);
        System.out.println("Flys类中的静态方法，调用Cars类中的静态成员变量："+Cars.age);
        //调用Cars类中的实例方法,只能通过对象调用
        ca3.shiLi();
        //调用Cars类中的静态方法，即可以通过对象调用，也可以通过类名调用
        ca3.staticCars();
        Cars.staticCars();
    }
}

public class TestMain {
    public static void main(String[] args) {
       //创建一个Flys类的对象
        Flys fl=new Flys();
        //用对象调用Flys类的实例方法
        fl.shiLiFlys();
        //用类名调用Flys类的静态方法
        Flys.staticFlys();
    }
}

总结：

          其他类的方法中访问另一个类的构造方法--使用关键字new
          访问另一个类的实例方法/实例变量--使用对象
          访问另一个类的静态方法/静态成员变量--使用类名/对象

六、不同类中调用有参数的方法

        传递参数有两个重点：

                        1.看方法有没有参数，有几个参数，参数的数类型是什么

                        2.传参-----两种方式（值传递/变量传递）

public class Park {
    //定义Park类中的无参数的构造方法
    public Park(){
        System.out.println("我是Park类中的无参数的构造方法");
    }
    //定义Park类的有参数的构造方法
    public Park(int width){
        System.out.println("我是Park类有一个参数的构造方法，我的参数是："+width);
    }
    //定义Park类的有两个参数的构造方法
    public Park(int width,String name){
        System.out.println("我是Park类有两个参数的构造方法，我的长度是："+width+",我的名字是："+name);
    }
    //定义Park类的有一个参数的实例方法
    public void parkShiLi(String name){
        System.out.println("我是Park类有一个参数的实例方法，我的参数是："+name);
    }
    public void parkShiLi1(String name,double rongliang){
        System.out.println("我是Park类有两个参数的实例方法，我的参数是："+name+"，我的容量是："+rongliang);
    }
    //定义Park类的有参数的静态方法
    public static void staticParkFangFa(double pingfang,int rongliang){
        System.out.println("我是Park类有两个参数的静态方法，我的面积是："+pingfang+"平方米，我能容纳："+rongliang+"人");
    }
}

public class TestMain {
    public static void main(String[] args) {
        //访问Park类中有参数的构造方法
        //创建一个Park类的对象
        Park pa = new Park(10000);
        new Park(10003,"大雁塔");
        //访问Park类中的有参数的实例方法
        Park pa1 = new Park();
        pa1.parkShiLi("长安广场");
        pa1.parkShiLi1("万科广场",8848.32);
        //用对象调取Park类中的有参数的静态方法
        pa1.staticParkFangFa(109323.33,19988392);
        //用类名调用Park类中的有参数的静态方法
        Park.staticParkFangFa(773828.23,877237823);
    }
}

七、接收有返回值的方法

        用与返回值同类型的变量接收

public class Man {
    //定义一个有返回值的实例方法
    public int manShiLi(){
        System.out.println("我是Man类的有int型返回值的无参数的实例方法");
        return 1;
    }
    //定义一个有返回值，有一个参数的实例方法
    public String manShiLi1(int age){
        System.out.println("我是Man类的有String型返回值的有一个参数的实例方法，参数为："+age);
        return "ok";
    }
    //定义一个有返回值，两个参数的实例方法
    public boolean manShiLi2(String name,int age){
        System.out.println("我是Man类的有boolean型返回值的有两个参数的实例方法，我叫："+name+",今年："+age);
        return true;
    }
    //定义一个有返回值，没有参数的静态方法
    public static float staticFangFa(){
        System.out.println("我是Man类的有float型返回值的没有参数的静态方法");
        return 1.0f;
    }
    //定义一个有返回值，有一个参数的静态方法
    public static long staticFangFa1(long tel){
        System.out.println("我是Man类的有long型返回值的有一个参数的静态方法，我的电话是："+tel);
        return 23443434324L;
    }
    //定义一个有返回值，有两个参数的静态方法
    public static String staticFangFa2(int age,String address){
        System.out.println("我是Man类的有String型返回值的有两个参数的静态方法，我今年："+age+"岁，我住在："+address);
        return "真实";
    }
}

public class TestMain {
    public static void main(String[] args) {
        //创建一个Man对象
        Man re = new Man();
        //用Man实例方法同类型的变量接收实例返回值
        int res = re.manShiLi();
        System.out.println(res);
        String res1 = re.manShiLi1(23);
        System.out.println(res1);
        int myage = 34;
        String res2 = re.manShiLi1(myage);
        System.out.println(res2);
        boolean res3 = re.manShiLi2("张三",34);
        System.out.println(res3);
        //用Man实例方法同类型的变量接收静态方法的返回值
        float statre = Man.staticFangFa();
        System.out.println(statre);
        long lres = Man.staticFangFa1(18767662773L);
        System.out.println(lres);
        String stringres = Man.staticFangFa2(37,"西安雁塔区");
        System.out.println(stringres);
    }
}

总结，不同Java类之间，变量和方法调用情况：

        1.实例变量只能对象访问，静态成员变量既可以对象访问，也可以类名访问

        2.构造方法通过 new +构造方法访问，实例方法只能通过对象访问，静态方法既可以通过对象访问，也可以通过类名访问

        3.方法参数值传递，要什么，给什么，注意参数个数和数据类型一致

        4.返回值接收，用与方法返回值类型 相同的变量进行接收