java中的类和对象（3）

4.11.什么是对象？
  1.对象是由我们自己创建的类来创建出来的。
  2.对象就是类的实例【可以真正使用类的数据，可以调用类中元素的数据】
  例如：修建大楼是绘制的设计图纸就是类，根据设计图纸修建起来的真实的可以住人的大楼就是对象。
  3.一个类可以创建出多个对象
4.12.如何创建对象？
  1.保证用来创建对象的类是存在
  2.需要通过类中提供的构造方法创建对象
  格式 ： new 构造方法( [参数值] );
例如：

class Lian{
     public Lian(){
        System.out.println("Lian类无参数构造方法");
     }
     public Lian(String jie){
       System.out.println("Lian类有参数构造方法,参数--jie=="+jie);
        }
 }
public class Lian1{
       public static void main(String arg[]){
       //创建Lian类的对象
       //格式:new  构造方法([参数值])
       //new  Lian();//Lian类的对象
       //new  Lian("java");
       //为了以后方便使用对象,我们就把这个对象保存在变量
       Lian stu=new Lian();
       }
 }

运行结果：

4.13.创建好的对象的有何作用？
  创建好的对象可以访问/调用类中的元素【变量/方法】，至于创建好的对象可以访问/调用类中的那些元素，那些元素不能访问/调用，就得看类中元素的访问限制修饰符。
4.14.对象的具体用法
变量的访问
  1.实例变量—【对象.实例变量】
  2.静态成员变量–【对象.静态成员变量/类名.静态成员变量】
以上的访问是在public修饰符的作用下操作的。
例如：

class LianXi{
        //实例变量
         public int sid=1008611;
         public int sage;
        //静态成员变量
         public static String sname="wangmazi";
         public static String saddress;
   }
         public class Lian2{
         public static void main(String args[]){
         //访问实例变量---【对象.实例变量】
         //创建LianXi类的对象
         LianXi s1=new LianXi();
         System.out.println("sid=="+s1.sid);
         //赋值
         s1.sage=18;
         System.out.println("sage=="+s1.sage);
         //访问类变量--【对象.类变量/类名.类变量】
         LianXi s2=new LianXi();
         System.out.println("sname=="+s2.sname);
         System.out.println("sname=="+LianXi.sname);
          //s2.saddress="北京";
         //System.out.println("saddress=="+s2.saddress);
         //System.out.pritnln("saddress=="+LianXi.saddress);
          LianXi.saddress="青海";
          System.out.println("saddress=="+s2.saddress);
          System.out.println("saddress=="+LianXi.saddress);
           }
}

运行结果：

方法的访问
  1.构造方法—new 构造方法();
  2.实例方法–【对象.实例方法】
  3.静态方法–【对象.静态方法/类名.静态方法】
例如:

class Cai{
          //实例方法
          public void c1(){
                  System.out.println("Cai类中的实例方法");
           }
           //类方法
          public  static void c2(){
                  System.out.println("Cai类中的类方法");
           }
  }
public class Lian3{
        public static void main(String  args[]){
          //实例方法--【对象.实例方法】
              Cai  cc=new Cai(); 
              cc.c1();
           //静态方法--【对象.静态方法/类名.静态方法】
              Cai cc2=new Cai();
              cc2.c2();
              Cai.c2();
          }
  }

运行结果:

有参数的方法访问，需要注意的是参数的传递
例如：

   class Ca{
          //实例方法
          public  void  c1(int age,double height){
            System.out.println("Ca类中的实例方法--参数1--age=="+age+",参数2-height=="+height);
             }
         //类方法
          public  static void  c2(Cai  cai){
            System.out.println("Ca类中的类方法--参数--cai=="+cai);
             }
         }
   public class Lian4{
          public static void main(String args[]){
                 //实例方法--【对象.实例方法】
                     Ca  cc=new Ca();
                     cc.c1(8,8.8);
                     //类方法
                     Ca.c2(new Cai());
                     //上面的方法在调用的时候传递的参数是具体的数据值
                     //我们在访问的时候可以传递保存数据值的变量
                      int age=6;
                      double hei=8.8;
                      cc.c1(age,hei);
                      Cai cai=new Cai();
                      cc.c2(cai);
               }
}

总结: 先看【有没有/有几个/什么类型】，再传【匹配类型/匹配个数/值【变量】】
有返回值的方法访问，需要注意的是接收方法的返回值结果【类型匹配】
例如：

 class Ca{
   //实例方法
   public int  c1(int num1,double num2){
      int res=0;
      res=(int)(num1+num2);
      return res;
       }
      //类方法
    public static Lian2 c2(Cai cai){
       //return  new  Lian2();
           Lian2  s1=new Lian2();
           return s1;
      }
 }
    public class Lian5{
            public   static void main(String args[]){
            Ca c3=new Ca();
            int val=c3.c1(8,8.5);
            System.out.println("c1的运行结果=="+val);
         }
}

总结：方法的调用【1.要什么，传什么；2.给什么，收什么】
4.15.对象的内存分配原理
对象是通过类的构造方法创建
类是一种自定义的复合数据类型

4.16.类与对象的关系
类是创建对象的模板；对象是类的具体表现
4.17.静态成员变量【类变量】与实例变量的区别
区别:

实例变量的数据值是不能再同类对象之间共享。
例如：

class App{
         public  String appname="抖音";
       }
public  class Lian6{
          public static void main(String args[]){
           App a1=new App();
           a1.appname="火山视频";
           System.out.println("a1=="+a1.appname);
           App a2=new App();
           System.out.println("a2=="+a2.appname);
        }
}

运行结果：

类变量的数据值是能在同类对象之间共享。
例如：

class  App{
         public static String appname="抖音";
       }
public  class Lian7{
           public static void  main(String args[]){
                    App a1=new App();
                    a1.appname="火山视频";
                    System.out.println("a1=="+a1.appname);
                    App a2=new App();
                    System.out.println("a2=="+a2.appname);
        }
}

运行结果：