java基础

4.类和对象

4.1.类是什么？

答： 通过java语言描述一组性质或特征相同或相似事物的自己定义的复合数据类型。

4.2.类是如何编写的？

答：通过class关键字来创建一个类。

格式：访问限制修饰符   class    类名{ 

           }

例如：

创建一个学生类

public  class  Student{

}

class  Student{

}

1. 访问限制修饰符---public  缺省的

                   public----[公共的] 所有包都可以访问

                   缺省的--[友好的] 同一个包中可以访问。

     2.class---创建类的关键字【类的标志】

     3.类名--合法的标识符【每一个的单词的首字母大写】

     4.{}----类体

4.3类中可以编写什么？

答：变量和方法

4.4 类中的变量的分类以及特征？成员变量的隐藏？静态成员变量与实例变量的区别？

答：

1.成员变量【全局变量】---类中除过方法以外的地方【在类体，但没有在方法中】。

2.局部变量---类中的方法里面和方法的参数。

例如：

public class TestClass1 {

         int  num=1;//成员变量【全局变量】、

         public void  my1(){

                double dou=12.5;//局部变量

         }

}

成员变量【全局变量】的特征

1.类中除过方法以外的地方。

2.可以没有初始值，系统会自动赋予这个全局变量一个默认的初始值。

3.需要访问限制修饰符

4.可以在本类中的任何一个方法中被使用，且不受访问限制修饰符的影响。

局部变量的特征

1.类中的方法里面和方法的参数。

2.局部变量一定要有初始值。

3.不能有访问限制修饰符

4.只能在定义该局部变量的方法中使用，超出本方法就错误

成员变量的隐藏

类中的某一个成员变量的名称与某一个方法中的局部变量的名称相同，那么类中的成员变量的数据值被局部变量覆盖隐藏

例如：

public class TestClass3 {

         //成员变量

         public int  test1=1001;

         public void  my1(){

                  //局部变量

                  char test1='A';

                  System.out.println(test1); //A

                  //如果需要强制性使用被局部变量影藏的这个成员变量的数据值

                  //那么就需要给这个变量前面使用“this.”,

                  //就可以使用被局部变量影藏的这个成员变量的数据值

                  System.out.println(this.test1); //1001

         }

}

静态成员变量与实例变量的区别

有static关键字修饰的成员变量-----静态成员变量【类变量】；

没有static关键字修饰的成员变量---实例成员变量【实例变量】；

1.语法定义上：静态成员变量有static,实例变量没有static

2.调用方式上：静态成员变量可以使用对象调用，也可以使用类名调用, 实例变量只能通过对象调用

3.内存配置上：静态成员变量是在程序运行之前分配内存空间，实例变量是在程序运行时分配内存空间

4.5 类中的方法以及表现形式和特征？方法的重载？

答：

方法：

       用来描述具有共同性质的一组事物的基本行为。

1. 普通方法【实例方法】基本格式：

    访问限制修饰符  方法的返回值类型  方法的名称(方法参数列表){

               需要实现的基本行为

     }

     访问限制修饰符---public   缺省的

     方法的返回值类型---方法执行成功以后的结果的数据类型

                --有结果，方法的返回值类型就是结果类型【基本类型，复合数据类型】，方法体的最后一句话是return xxx；语句

                --没有结果，使用void表示

     方法的名称----合法的标识符【首字母小写，从第二个单词开始首字母大写】

               test   testHello    testHelloWorld
    方法参数列表---接收方法以外的数据进入本方法【请人帮忙】

               ---可以一个参数都没有（）。

               ---可以有一个/多个（变量）/(int  num1,double test1,String  test)

    {}---方法体

例如：

package com.click369.method1;

 

public class TestMethod1 {

         public void test1(){

                  System.out.println("public修饰的没有返回值，没有参数，名称是test1的方法");

         }

         void test2(){

                  System.out.println("缺省修饰符修饰的没有返回值，没有参数，名称是test2的方法");

         }

         public int test3(){

                  System.out.println("public修饰的返回值为int，没有参数，名称是test3的方法");

                  return 100;

         }

         String test4(){

                  System.out.println("缺省修饰符修饰的返回值为String，没有参数，名称是test4的方法");

                  return "100";

         }

         public int test5(int num){

                  System.out.println("public修饰的返回值为int，有一个int型参数，名称是test5的方法");

                  return 100+num;

         }

         double test6(int num,double test){

                  System.out.println("缺省修饰符修饰的返回值为double，有两个参数，名称是test6的方法");

                  return num+test;

         }

}

2.静态方法【类方法】基本格式：

访问限制修饰符  static 方法的返回值类型  方法的名称(方法参数列表){

       需要实现的基本行为

}

例如：

package com.click369.method1;

 

public class TestMethod2 {

         public static void test1(){

                  System.out.println("public修饰的没有返回值，没有参数，名称是test1的静态方法");

         }

         static void test2(){

                  System.out.println("缺省修饰符修饰的没有返回值，没有参数，名称是test2的静态方法");

         }

         public static int test3(){

                  System.out.println("public修饰的返回值为int，没有参数，名称是test3的静态方法");

                  return 100;

         }

         static String test4(){

                  System.out.println("缺省修饰符修饰的返回值为String，没有参数，名称是test4的静态方法");

                  return "100";

         }

         public static int test5(int num){

                  System.out.println("public修饰的返回值为int，有一个int型参数，名称是test5的静态方法");

                  return 100+num;

         }

         static        double test6(int num,double test){

                  System.out.println("缺省修饰符修饰的返回值为double，有两个参数，名称是test6的静态方法");

                  return num+test;

         }

}

3.构造方法：

       没有方法返回值类型部分

       方法的名称与类名称相同

访问限制修饰符    类名称(方法参数列表){

       需要实现的基本行为

}

注意：

1.用来创建对象的方法。

2.当我们创建好一个类以后，默认就有一个无参数的构造方法存在，只是没有显示出来。

3.当类中出现有参数的构造方法时，我们最好将无参数的构造方法,手动显示出来，如果没有手动显示出无参数的构造方法，那么有参数的构造方法会将原本默认存在的无参数的构造方法覆盖。

例如:

public class TestMethod3 {

         public TestMethod3(){}

         public TestMethod3(String test){

         }

}

方法的重载：

     方法的重载---在同一个类中，方法名称相同，参数不同这种现象就是方法重载。

     参数不同--1.有或无

                  --2.数量不同

                  --3.类型不同

    注意：方法重载与方法的返回值类型，没有关系。

例如：

public class TestMethod4 {

         //构造方法重载

         public TestMethod4(){}

         public TestMethod4(String test){    

         }

        public TestMethod4(String test,int num){

         }

        public TestMethod4(int num){            

        }

    //实例方法重载

      public void test1(){}

      public int test1(String test){

               return 100;

      }

      public int test1(int test){

               return 100;

      }

      public void test1(int num1,int num2){}

       //静态方法重载

      public static void testStatic1(){}

      public static int testStatic1(String test){

               return 100;

      }

      public static int testStatic1(int test){

               return 100;

      }

      public static void testStatic1(int num1,int num2){}

}

4.6 同一个类中方法与变量的调用关系？方法与方法的调用关系？

答：

1. 在同一个类中只能方法调用变量，不能变量调用方法

同一个类中方法调用变量

例如：

package com.click369.test1;

public class TestClassDemo5 {

         //实例变量【没有staatic修饰的成员变量】

         public  int  shilibianlang=1001;

         //静态成员变量【类变量：有staatic修饰的成员变量】

         public static  String staticbianliang="类变量";

         //构造方法

         public  TestClassDemo5(){}

         public  TestClassDemo5(int num){

                  //1.构造方法可以调用实例变量，默认是this.实例变量，this.可以省略

                  System.out.println(this.shilibianlang);

                  System.out.println(shilibianlang);

                  //2.构造方法可以调用类变量，默认是类名.类变量，类名.可以省略，也可以是this.类变量，this.可以省略

                  System.out.println(TestClassDemo5.staticbianliang);

                  System.out.println(this.staticbianliang);

                  System.out.println(staticbianliang);

         }

        

         //实例方法

         public void test1(){}

         public int test2(int num){

                  //1.实例方法可以调用实例变量，默认是this.实例变量，this.可以省略

                  System.out.println(this.shilibianlang);

                  System.out.println(shilibianlang);

                  //2.实例方法可以调用类变量，默认是类名.类变量，类名.可以省略，也可以是this.类变量，this.可以省略

                  System.out.println(TestClassDemo5.staticbianliang);

                  System.out.println(this.staticbianliang);

                  System.out.println(staticbianliang);

                  return num;

         }

        

         //静态方法【类方法】

         //静态方法【类方法】中你绝对不能出现this

         public static void teststatic1(){}

         public static int teststatic2(int num){

                  //1.类方法不可以调用实例变量

                  //System.out.println(this.shilibianlang);

                  //System.out.println(shilibianlang);

                  //2.类方法可以调用类变量，默认是类名.类变量，类名.可以省略

                  System.out.println(TestClassDemo5.staticbianliang);

                  //System.out.println(this.staticbianliang);

                  System.out.println(staticbianliang);

                  return num;

         }

}

 

 

同一个类中方法调用方法

package com.click369.test1;

public class TestClassDemo6 {

         //构造方法

         public  TestClassDemo6(){}

         public  TestClassDemo6(int num){

                  //构造方法可以调用其他的构造方法，new + 其他的构造方法;

                  new TestClassDemo6();

                  //构造方法可以调用实例方法，默认this.实例方法，this.可以省略

                  this.test1();

                  test1();

                  //构造方法可以调用类方法,默认类名.类方法，类名.可以省略，也可以是this.类方法，this.可以省略

                  TestClassDemo6.teststatic1();

                  this.teststatic1();

                  teststatic1();

         }

        

         //实例方法

         public void test1(){}

         public int test2(int num){

                  //实例方法可以调用其他的构造方法，new + 其他的构造方法;

                  new TestClassDemo6();

                  //实例方法可以调用其他实例方法，默认this.实例方法，this.可以省略

                  this.test1();

                  test1();

                  //实例方法可以调用类方法,默认类名.类方法，类名.可以省略，也可以是this.类方法，this.可以省略

                  TestClassDemo6.teststatic1();

                  this.teststatic1();

                  teststatic1();

                  return num;

         }

        

         //静态方法【类方法】

         //静态方法【类方法】中你绝对不能出现this

         public static void teststatic1(){}

         public static int teststatic2(int num){

                  //类方法可以调用其他的构造方法，new + 其他的构造方法;

                  new TestClassDemo6();

                  //类方法不可以调用实例方法

                  //this.test1();

                  //test1();

                  //类方法可以调用类方法,默认类名.类方法，类名.可以省略

                  TestClassDemo6.teststatic1();

                  //this.teststatic1();

                  teststatic1();

                  return num;

         }

}

总结：

        1.静态方法【类方法】中绝对不能出现this

        2.静态方法【类方法】中不能调用实例变量和实例方法

        3.构造方法可以调用实例变量/实例方法，默认是this.实例变量/this.实例方法，this.可以省略。

        4.构造方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略，也可以是this.类变量/this.类方法，this.可以省略。

        5.构造方法可以调用其他的构造方法，new + 其他的构造方法;

        6.实例方法可以调用实例变量/实例方法，默认是this.实例变量/this.实例方法，this.可以省略。

        7.实例方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略，也可以是this.类变量/this.类方法，this.可以省略。

        8.实例方法可以调用构造方法，new + 其他的构造方法;

        9.类方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略。

        10.类方法可以调用构造方法，new + 其他的构造方法;

4.7 对象是什么？对象如何创建？创建好的对象的作用？

答：对象就是通过类创建出来的实体/实例，因此我们把创建对象的过程就叫实例化。【创建对象】

对象如何创建

1. 对象就是通过类创建出来的实体
2. 通过 new + 构造方法 创建的。
3. 定义格式：类名  对象名称； 
4. 创建格式：对象名称=new 构造方法; 
5. 定义+创建格式: 类名  对象名称=new 构造方法;

例如：

public  class  Student{

//定义格式：类名  对象名称； 

Student  stu1;   ====>  int  num1;

//创建格式：对象名称=new 构造方法; 

stu1=new Student(); ===>  num1=100;

//定义+创建格式: 类名  对象名称=new 构造方法;

Student stu2=new Student();=====>int  num1=100;

}

对象的作用

1. 可以通过对象来调用定义在类中的变量【实例变量/类变量】，和方法【实例方法/类方法】，忽略访问限制修饰符的影响。
2. Java程序=对象+消息【类中的变量，方法】
3. 其他类中实例变量/实例方法只能对象调用。
4. 其他类中类变量/类方法，可以对象调用，也可以类名调用。

例如：

package com.click369.test1;

/**

 * 学生类

 * @author Administrator

 *

 */

public class StudentBean {

         //成员变量 

         //1.可以没有初始值

         //2.可以在本类中的任意一个方法中被调用

    //实例变量

         public  int  stuid;

         public  String stuname;

         public  int  age;

         public  String stuaddress;

         //类变量

         public static String classname;

        

         //构造方法

         public StudentBean(){

                  System.out.println("StudentBean类的无参数构造方法");

         }

        

         public StudentBean(String val){

                  System.out.println("StudentBean类的有参数构造方法，参数val的值是=="+val);

         }

         //实例方法

         public  void  test1(){

                  System.out.println("StudentBean类的无参数实例方法");

         }

         public  void  test2(int  num){

                  System.out.println("StudentBean类的有参数实例方法，参数num的值==="+num);

         }

         //类方法

         public static void  testStatic1(){

                  System.out.println("StudentBean类的无参数类方法");

         }

         public  static void  testStatic2(char  ch){

                  System.out.println("StudentBean类的有参数类方法，参数ch的值==="+ch);

         }

}

 

package com.click369.test1;

/**

 * 主类--包含主方法【mian】的类就是主类

 * @author Administrator

 *

 */

public class TestMain {

         //主方法【mian】

         public static void main(String[] args) {

                  //定义对象

                  StudentBean stu1;

                  //创建对象

                  stu1=new StudentBean();

                  //定义+创建

                  //StudentBean stu2=new StudentBean("参数是字符串");

                  //通过对象调用实例变量

                  stu1.stuid=1001;

                  stu1.stuname="zhangsan";

                  stu1.age=23;

                  stu1.stuaddress="西安";

                  System.out.println(stu1.stuid+"\t"+stu1.stuname+"\t"+stu1.age+"\t"+stu1.stuaddress);

                  //通过对象调用实例方法

                  stu1.test1();

                  stu1.test2(100);

                  //类变量可以通过对象调用

        stu1.classname="java班";    

        //类变量也可以通过类名调用

        System.out.println("班级名称=="+StudentBean.classname);

        //类方法可以通过对象调用

                  stu1.testStatic1();

                  //类方法也可以通过类名调用

                  StudentBean.testStatic2('A');

         }

}

4.8 对象的内存分配原理？

    对象是通过类创建的，而类是一种复合数据类型，那么对象的内存分配与复合数据类型的内存分配是一致。因此对象的内存分配会在内存的堆区和栈区都有分配。

4.9 对象的使用？

答：1.先new  2，要什么，给什么  3. 给什么，收什么

4.10 类与对象的关系？

答：

以实例方法为例，解释对象调用方法的关系

没有参数，没有返回值

没有参数，有返回值

有参数，没有返回值

有参数，有返回值

例如：

package com.click369.test2;

public class UserBean {

         public void testUser1(){

                  System.out.println("UserBean类的testUser1的实例方法");

         }

}

package com.click369.test2;

/**

 * 个人信息类

 * @author Administrator

 *

 */

public class PersonBean {

 

         //1.没有参数，没有返回值

         public  void  test1(){

                  System.out.println("没有参数，没有返回值");

         }

         //2.没有参数，有返回值

         public  String  test2(){

                  System.out.println("没有参数，有返回值");

                  return "hello";

         }

         //3.有参数，没有返回值

         public  void  test3(int num1,double num2){

                  System.out.println("有参数，没有返回值");

                  System.out.println("int num1=="+num1);

                  System.out.println("double num2=="+num2);

         }

         //4.有参数，有返回值

         public  double  test4(int num1,double num2){

                  System.out.println("有参数，有返回值");

                  System.out.println("int num1=="+num1);

                  System.out.println("double num2=="+num2);

                  return num1+num2;

         }

//5.参数为复合数据类型

         public  void  test5(UserBean user){

                  System.out.println("参数为复合数据类型");

                  user.testUser1();

         }

         //6.返回值为复合数据类型

         public  UserBean  test6(){

                          System.out.println("返回值为复合数据类型");

                          //UserBean  user=new UserBean();

                          //return user;

                          return new UserBean();

                  }

}

 

 

package com.click369.test2;

 

public class TestMain {

 

         public static void main(String[] args) {

                  PersonBean person=new PersonBean();

                  //1.调用没有参数，没有返回值

                  //person.test1();

                  //2.调用没有参数，有返回值,创建变量接收方法的返回值结果

                  //String value=person.test2();

                  //System.out.println("test2方法的执行结果=="+value);

                  //3.调用有参数，没有返回值,传入参数值

                  //person.test3(100, 12.5);

                  //int  a=100;

                  //double b=12.5;

                  //person.test3(a,b);

                  //4.调用有参数，有返回值,传入参数值,创建变量接收方法的返回值结果

                  //double num=person.test4(100, 12.5);

                  //System.out.println("test4方法的执行结果=="+num);

//5.调用参数为复合数据类型的方法

                  //person.test5(new UserBean());

                  //UserBean  user=new UserBean();

                  //person.test5(user);

                  //6.调用返回值为复合数据类型的方法

                  UserBean user=person.test6();

                  user.testUser1();

         }

}

   总结：   类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。