2、类与对象

java学习过程:给你一辆自行车,先会骑,再会修;先抓骨架,后磨细节。

 

像Java这样的纯面向对象语言,类是最基本的抽象单位,知识点:继承、多态、封装,作用域及生命周期。

 

一、类的创建及初始化

类通常是一类事物的抽象,如人就是一个类,你、我、他是这个类的具体实例,也就是对象。在Java中我们可以通过形如:class A {}来创建一个类,我们说过Java是面向对象的语言,每个对象都应该拥有它自己的属性和方法,就拿人来说,肤色、身高等是人的属性,吃、喝、玩等都是方法,也就是说属性描绘了类的特点,而方法描述了类的功能,体现在Java的类中就像下面的代码这样:

class People{
   private int age;
   eat();
}

 在面向对象的思想中,一切皆对象,我们以对象为单位进行编程,将这个对象所有的属性方法包装在一起,就是封装。一般情况,我们通过类的构造器来创建类对象,构造器是一个拥有和类名同样的名字的方法,我们可以对它传递参数,进行一些初始化工作,如,当我们需要在创建对象的时候,初始化其姓名及年龄,我们 可以这样来做:

 

class People{
   private name;
   private age;
   public People(String name,int age){
       this.name=name;
       this.age=age;
   }
}
 测试类:

 

 

public class Test{
   public  static main(String[] args){
        People person=new People("skx",28);
    }
}
new 操作符会为我们在内存中开辟空间(后面会详细讲解堆栈内存),person是对象名,也是引用,在栈上分配,指向由new在堆上分配的内容,具体由JVM内存管理,这里不深讲。我们再来分析一下这个过程:当调用new Person()时,编译器首先检查下原类Person中是否有Person()构造方法,此处因为有 public Person(String name,int age),所以new的时候,直接调用的该方法,但是很多时候,我们并没有显示声明构造方法,此时,编译器在调用的new Person()的时候,会自动为我们的Person类添加一个无参的空Person()构造方法:Person(){},来执行类的构造过程。

 

 

&&:变量无论放在什么地方,都会先于任意一个方法的执行前执行,包括构造方法,而构造方法是一个类(创建时)必须会执行的方法,不需要显示的进行调用。同时,不论变量在哪儿分布,只要在方法外部,就一定先于方法初始化。

 

    public class Person {    
        public Person(int id) {  
            System.out.println("person(" + id + ")");  
        }  
        //静态方法优先于普通方法(赋值,实例是普通方法);
        public static void main(String[] args) {  
            Build b = new Build();  
        }  
    }  
      
    class Build {  
        //p1是Build的属性,优先于构造方法Build()执行,将执行Person(1);
        Person p1 = new Person(1);   
        public Build() {             //在这里,将最后执行
            System.out.println("this is build's block!");  
            Person p2 = new Person(2);  
        }  
        //p3是Build的属性,优先于构造方法Build()执行,将执行Person(3);  
        Person p3 = new Person(3);   
    }  
  另一个关键的知识点静态块和非静态块。二者都有很简单的声明方式,只需一对大括号{}就行,静态块的话,在前面加static关键字,我们写个小程序来看看:

 

    public class Person {  
        /*静态块,与主静态方法依顺序执行,只执行一次*/  
        static{  
            System.out.println("this is static block!");  
        }  
        /*非静态块,执行2次*/  
        {  
            System.out.println("this is non-static block!");  
        }  
        public Person(int id) {  
            System.out.println("person(" + id + ")");  
        }  
        public static void main(String[] args) {  
            Person p1 = new Person(1);  
            Person p2 = new Person(2);  
        }  
    }  

 该程序输出:

this is static block!
this is non-static block!
person(1)
this is non-static block!
person(2)
&&:静态块是在类装载时执行的(编译成.class文件,第一次被调用、应用时),且只执行一次。而非静态块是在调用构造方法之前执行的,每生成一个实例对象,就会调用一次非静态块。

class A{
	static{		
		System.out.println("1111");
	}
	{
			System.out.println("3333");
	}
	static void print(){
		System.out.println("jjjjjjj");
	}	
}
public class Extends extends A{
  public static void main(String[] args){	  
	System.out.println("22");
  }
}  

输出结果:

1111

22

这里没有调用A的构造函数,只是对A.class进行了加载,所以只运行A的静态块;而静态方法[实例调用才会执行]和非静态块[也需要实例调用时执行]没有被执行。

此处,我想引入一个很重要的知识点:static键字。一般来说,被声明为static的变量或者方法,或者前面说的块,都属于静态属性、静态方法(有时称:类属性、类方法不,不要和全局属性混淆,全局属性:在类中声明的普通属性,与局部属性对应),属于类级属性(想象为类的原型属性,在方法区分配内存)。如静态块一样,其它的静态属性也具有这个特点:初始化只在类装载的时候执行一次。对于类变量和类方法,还有一个重要的特点就是,外部对象对他们的引用可以直接通过类名来调用。

 

除了使用new操作符,我们还有一些其它方法来创建类,如Java的反射机制,后面会有专门的文章来介绍相关的知识点。

public  class A{
   public static  void  main(String[] args){
         A a=new A();
     ]
}
主方法可以放在在其他任意类中,可以理解为主方法在另外一个class B中定义的,要调用A的属性,先声明创建A实例;

 总体来说执行顺序为:静态块,静态属性->静态方法->非静态块,属性->构造器;对于静态块和静态属性或者非静态块和属性,初始化顺序决定于它们在代码中的顺序。

接下来我们分析一下类的属性和方法

 

属性:

类中的属性一般分为类属性(静态属性)、实例属性(全局变量)、局部属性(局部变量)。

类属性:前面已经说过就是那些声明为static的属性,在整个过程中只进行一次初始化,在内存中只开辟一个空间,不论在哪儿调用,值保持一致。一旦被修改,所有引用它的地方都会跟着修改。一般直接通过类名进行调用。

实例属性:实例变量是可以不进行初始化(只声明),比如一个整型没有初始化,则默认值为0,String为null;而局部变量假如不赋初值语法上是通过的,但是在使用这个变量是程序就报错了。基本数据类型在栈中分配内存,引用数据类型在堆栈中都分配内存,在堆当中分配的是对象本身,而栈中则是对这个对象的引用。

局部属性:局部变量是在方法内部声明的变量,生命期仅在方法内,方法结束后变量就消失了;局部变量必须初始化再使用,否则会报错,也就是说,假如你在方法内定义了一个局部变量,并且没有赋值,那么你在使用这个变量的时候一定得赋值,不然就报错了。同时,局部变量可屏蔽全局变量。

 

 

方法:

方法就是类的行为,形如: public void say(){ dosomething...};由方法头和方法体构成,方法头包括:访问控制符(如public private等)、返回类型(取决于方法返回值类型)、方法名、参数列表组成。声明为void的方法,返回值为空。在特殊的情况 下,我们可以为方法添加一些特殊的关键字以实现特殊的功能,如synchronized、final、static、abstract等等。两个重要的方面:重载(Overload)和重写(Override也称覆写)。

 

重载:

是指在同一个类中,具有相同的方法名,不同的参数列表的方法之间的一种机制。参数列表的不同体现在:类型不同、个数不同、顺序不同,只要满足任一一个,就可以进行方法重载。

若用同一个方法名print,同步传入不同的参数,实现不同的功能,这就是方法重载,用这样的机制有什么好处?个人感觉就是在模型上的一种统一,同样的功能,调用同样的方法,只需传入不同的参数,增强了程序的可读性和易于维护,当有很多个功能相似的方法的时候,如果我们为多个方法只设计了一个名称,想通过名称来区分它们的话,会很糟糕,而且会让人觉得程序的可读性差,设计不够巧妙!此处问题来了:我们可不可通过方法的返回值来区别方法重载?

&&:当调用两个不同返回类型,其他参数相同的方法时,并不会先得到他们的返回值,返回值只有在方法执行完毕才返回,在调用之初,编译器无法判断他们的区别,所以只能当同名方法来处理:报错!所以试图通过返回值来进行方法重载是不正确的!

重写:

重写是在继承中存在的,在两个类(子类和父类之间存在的关系)中,子类重写父类的方法,方法名相同,参数也相同的一种机制。

当子类继承了父类后,想对父类的方法功能进行扩展,就可以使用重写,这样做的目的就是:当你需要扩展新的功能的时候,不需要新建方法,在父类的方法中进行补充,这样一种面向对象思维的体现,不用重写同样可以达到这样的效果,但是用了重写更加符合OO思想。子类覆写父类方法,才能被识别;

&&:向上转型时,被覆写的方法,子类的方法优先于父类方法执行,但是,父类的属性不受影响!(详见后面的继承)

 

 不定参数方法

有的时候,我们不能确定方法的参数个数,我们可以采取这种机制(String ... args)或(String[]  args),如下面的代码:

public class Extends {
	public static void print(String...args){
		for(int i = 0;i<args.length;i++){
			System.out.print(args[i]+"  ");
		}		
	}
  public static void main(String[] args){	  
	print("sd","ew","we","dd");
  }
} 

 

如果你是高手来群指教:366437263   ,如果你是菜鸟,来我们一起进步。

欢迎继续学习!

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值