java类和对象实例分析

1，类和对象


 


在面向对象的概念当中，类（class）是既包括数据又包括作用于数据的一组操作的封装体。类的数据称为成员变量，类对数据的操作称为成员方法。成员变量反映类的状态和特征，成员方法反映类的行为和能力。类的成员变量和方法统称为类的成员。


 


对象(Object)是类的实例(instance)。对象是动态的，拥有生命周期，都会经历一个从创建、运行到消亡的过程。对象与类的关系就像变量与数据类型一样。


 


类声明


{ 修饰符 } class <Classname> { extends <Classname> }


                            { implements    <Interface1>,


                                         <Interface2>,


                     [..],


                     <InterfaceN> }


{


  // 类主体


}


 


声明成员变量


public class Person{


    private int age;
}


 


(声明)成员方法


[修饰符] 返回值类型 方法名([参数列表])[throws 异常类]


{


    语句序列;


    [return []]


}


 


public class class Person{


    private int age;


    public int getAge(){


         return age;


    }


   


    public void setAge(int a){


         age=a;


    }


}


 


声明main方法


public static void main(String [] args)


 


对象声明


Date aday;//声明一个是Date类的aday对象


 


对象实例化


创建类的实例必须调用类的构造方法。类的构造方法是一类和类同名的方法，用于创建类的实例并初始化对象。


对象 = new 类的构造方法([参数列表]);


aday = new Date();


当使用new创建了一个对象的时候，系统为对象中的成员变量进行了初始化，不但为变量分配了相应的存储单元，还为变量设置了所属数据类型的初始值。


 


方法调用时的参数传递原则


如果形参的数据类型是基本数据类型，则实际参数向形参传递的是值，即传值。


如果形参的数据类型是引用数据类型，则实际参数向形式参数传递的是引用。


这里随便用个例子来说明


public class Tester {    
    public static void main(String[] args) {    
        int primitive = 2;    
        changePrimitive(primitive);    
        //primitive的值依然是2    
        MyClass myClass = new MyClass();    
        changeObject(myClass);    
        //myClass仍然指向的是执行changeObject之前的那个对象 
        //myClass.i等于3了    
    }    
  
    public static void changePrimitive(int primitive) {    
        primitive = 3;    
    }    
  
    //在这里myClass1只是一个副本和myClass指向的是同一个对象，千万不要被去参数名称为myClass迷惑
    //这里我有意区分
    public static void changeObject(MyClass myClass1) {
        //这个时候对原来的对象的值操作有效，因为它指向的地址就是原来的对象
        myClass1.i = 3;
        //这里修改的只是副本指向的对象
        //而原来的myClass依然指向原来的对象
        myClass1 = new MyClass();    
    }    
}    
  
class MyClass {    
    int i;    
}   
2，继承，多态和封装


 


(1)封装性


 


声明构造方法


构造方法与类同名，构造方法返回的是该类的一个实例，不需要返回类型。


当一个类没有构造方法的时候，Java自动为该类生成一个默认的构造方法，默认构造函数没有参数。


public class Person{


     public Person(int age){


     }


    


     public Person(String name ,int age ){


     }


}


当一个类有了构造函数但是不是默认构造函数的时候，默认构造函数将不会被提供。


也就是说：Person p=new Person();是错误的。


 


重载


一个类中如果有多个同名的但是带有不同参数的方法列表，称为方法的重载。


 


this引用和instanceof对象运算符


this可以调用成员变量和成员方法，也可以指代对象本省，也可以调用本类的构造函数。


 


public class class Person{


    private int age;


    public int getAge(){


         return age;


    }


   


    public void setAge(int a){


         age=a;


    }


    public boolean equals(Person p1){


            Person p=this;


            return p1.getAge()==p.getAge();


    }


}


 


instanceof对象运算符判断一个对象是否属于指定类及其子类，返回boolean类型。


Person p=new Person();


return p instanceof Person;//返回true


 


类成员访问权限


 


  private成员 默认成员 protected成员 public成员
同一类中可见 是 是 是 是
同一包中对子类可见 否 是 是 是
同一包中对非子类可见 否 是 是 是
不同包中对子类可见 否 否 是 是
不同包中对非子类可见 否 否 否 是
 


实例成员与类成员 (类成员方法和实例成员方法)


类成员使用类名访问，声明类成员需要加上static，如下所示


public class Person1{


    String name;


    static int count;


}


 


访问方式为：假设一个对象p


Person1.count;


p.name;


 


 


继承


 


Java中只支持单继承，子类不能够继承父类的构造方法。但在子类当中可以使用super调用父类的构造方法。格式为super([参数列表])


子类可以对父类赋值兼容。


由于继承相对而言比较简单，所以不再赘述。 


 


多态性


 


多态性有两种


a，编译时多态。


b，运行时多态。


 


方法的多态性主要有方法的重载和覆盖。


方法的覆盖表现出两种多态性，当对象获得本类的实例时，为编译时多态性，否则为运行时多态性。


Person p=new Person();


Student stu=new Student();//假设Student是Person的子类,它们有同样的print()方法。


Person p1=new Student();


p.print();//编译时多态，执行本类方法


stu.print();//编译时多态，执行覆盖方法


p1.print();//运行时多态，执行Student覆盖方法


 


p1声明为父类对象但是却获得了子类的实例，那么它究竟执行的是子类覆盖方法还是父类方法呢？


这里有两种情况，这取决于子类是否覆盖了父类的该方法。如果子类覆盖了该方法，就执行子类的该方法，否则执行父类方法。但是在编译时，仅仅依据对象所属的类无法确定到底该执行哪个类的方法，只有到运行是才能呢个确定，所以是运行时多态。


 


这里请注意，父类对象并不能没有被子类覆盖的方法。


 


 


3,类和接口及抽象类内部类


 


//基本类


public class Manager extends Person implements Job{




}


 


//抽象类


public abastract class Person{


    String id;


    String name;


    int age;


    //对应get和set方法


    public abstract String goodAt();
}


 


//接口


public interface Job{


//abstract可有可无


    public abastract  String getJobName();


    public int getSalary();
}


 


//最终类


public final class Math extends Object{


}


 


如上，使用关键字abstract声明的类称为抽象类，使用abstract声明的成员方法为抽象方法，抽象类通常包含抽象方法，抽象方法是只有方法声明而没有方法体的成员方法。


抽象类不能被实例化。


抽象类中可以不包含抽象方法，但是包含抽象方法的类必须声明为抽象类。抽象方法必须被子类覆盖。


最终类不能被继承。


 


接口


 


接口是一组常量和抽象方法的集合。在Java中接口是一种引用数据类型。接口的作用是提供方法声明与方法实现分离的机制，使多个类之间表现出共同的行为能力。它有一下的特点。


 


1)接口及接口成员的访问权限都是public。


2)接口中的成员方法都是公有的抽象的实例成员方法。


3)接口中所有的抽象方法必须被实现接口的类全部覆盖。


4)接口中的成员变量都是常量。


5)接口不能被实例化。


6)接口是引用数据类型。


 


接口与抽象类


 


相同点：


两者都包含抽象方法，都不能被实例化。


两者都是引用数据类型，其变量可以被赋值为子类或者实现接口的类的对象。


 


不同点：


抽象类约定多个子类之间共同使用的方法;接口约定多个互不相关类之间共同使用的方法。


抽象类与子类之间采用单继承机制;一个类实现了多个接口实现了多继承的功能。


抽象类及其类中成员具有与普通类一样的访问权限;接口中的访问权限都是public。


抽象类可以包含非抽象的方法,也可以声明构造方法;接口中的方法全部都是抽象方法。


抽象类可以声明成员变量,子类可以对成员变量赋值;接口只能声明常量。


 


内部类


 


声明内部类
在一个类中包含另一个类的定义
内部类可以在类、方法甚至语句块中定义
内部类可以是private或protected


 


这里呢，我对内部类的理解不深入，所以需要重新整理了，到此为止吧，我将整理另外一篇有关内部类的文章。