您的位置:首页 > 编程语言 > Java开发

Java 面向对象基础

2017-03-21 11:17 281 查看
由于对此概念产生了模糊,所以再来总结学习一下,不对之处,请指正。

说起面向对象,首先要说明一下Java类,其本质是用来描述事物类型的。关于Java方法的创建和重载和类的定义、声明,由以下演示:

class  类名{//类名一般大写
属性;
方法:
访问修饰符 返回值类型 方法名(){
方法主体
}
}
其中,注意Java方法的返回值类型,如果没有特殊要求返回值类型,可以定义为void,这样就不需要在此方法结束的时候return一个该返回类型的值,除void以外的int、String、float等均需要返回对应类型的数值。

关于重载Java方法,即方法名相同,只是参数类型或者个数不同而已,如下。

public void Person(int age) {
}
public void Person(String name) {
}
从上边儿的示例可以看出,仅仅改变了Person传入参数的类型,即实现了Java方法的重载。

接下来看类与对象的关系:

1.类:就是对现实生活中事物的描述,主观抽象,是对象的模板,可以实例化对象。//映射到java中,描述就是class定义的类。

习惯上,类的定义中除了上文阐述的,还有一个默认的构造函数(或者称为构造器)。构造函数的作用主要是给对象进行初始化,当一个构造函数建立时,就会调用与之相对应的构造函数。而如果类中没有定义构造函数,则系统会默认给该类加入一个空参数的构造函数。构造函数的创建方法和Java方法的创建相似,因为其本质也属于一个Java方法。但在运行时有很大的区别,构造函数在对象建立时就会立即运行,给对象初始化,而一般Java方法则在对象调用该方法时才会被运行,同时,构造函数只运行一次。

class Person
{
//Person(){}  空参数构造函数。
private String name;
private int age;
public void main( String[] args)
{
System.out.println("person code run");
}
//函数的重载
Person()
{
System.out.println("A:name="+name+"..age="+age);
}
}
上述代码中,注释掉的Person(){},即为空参数构造函数,因为下面将该函数进行了重载,空参数Person()就不能再出现。

2.对象:就是这类事物,实实在在存在的个体,类的个体。//new 映射到堆内存中的一个实体。

先看一个简单的例子:
class  Demo
{
public static void main(String[] args)
{
Person per;//声明
per = new Person();//实例化
Person per = new Person();//声明并实例化
}
}
class Person{

}
其中,包含了一个类的声明、实例化方法。这里需要对实例化的过程说明一下,就拿
Person per = new Person("zhangsan",25);
这句代码来看,它具体的执行了哪些操作?
首先,new用到了Person.class,所以先找到该文件并加载到内存中。如果该类中有相对应的静态方法,则执行该方法对Person.class进行初始化。然后在堆内存中开辟空间,分配内存地址,其中的Person per是在栈内存中指向堆内存的,使用new开辟一个堆内存空间来对内存中建立的对象per进行默认初始化。对per属性进行初始化,比如name、age等,然后对对象进行对应构造函数的初始化,最后将内存地址赋予变量per。



3.面向对象的特征:封装、继承、多态
1>封装,顾名思义,就是将一个事物自我封装起来,外界看不到内部,只有自己可以看到自己内部,比如一个快递,用箱子封装起来一样,你不拆开箱子,你是看不到内部有什么东西的,而箱子内部的东西知道内部有什么(What the hell?我用了拟人的手法[手动滑稽])。而Java中的封装也一样,是为了不让外部访问到内部,只是提供一个接口,可以让外部来进行调用,具体内部的方法不会让你去修改,典型的封装就是jar包。
2>继承,也很简单,就是将父类的东西传承下来,在定义和实现一个子类的时候,不用再去重复的书写已有的方法,继承和封装的区别在于,前者可以对父类的一些方法进行复写和修改,而后者只能调用不能修改。继承提高了代码的扩展性和重复使用性。
3>多态,这个目前本人没有用到多,所以也不好说怎么使用,希望在以后的使用中再来完善。
4.说完了上述的一些基本内容,索性再来巩固一下基础知识,接下来,简单总结一下变量和访问修饰符等一些基础知识。
1>变量分为局部变量和全局变量,从名称就可以看出,二者的作用范围不同,如下

class  Demo
{
String name;
int age;
public static void main(String[] args)
{
float num;
char ch;
}
}
其中,name和age均作为全局变量存在,作用于整个类,而num和ch仅仅在main方法中可以调用。

2>几种访问权限

public:此种修饰,表示任何地方均可以访问。
protected:在此类内部,或者同一个包中,子类中均可以访问到,是介于public和private两者之间的一种访问修饰符。
private:仅限当前类内部访问。

public class TestDemo{
public void main(String[] args){
sop(t.getNum());
}

public void sop(Object object){
System.out.println(object);
}
}
class Num{
public int a = 1;
protected  b = 2;
private int c = 3;
public int getNum(){
return c;
}
}
可以看出,编译失败,因为c定义为private,仅限于内部类访问,所以不能被外部的class访问到,但是getNum()方法因为是public定义的,所以TestDemo可以访问到。

3>其他的一些修饰符
static:使用static修饰的方法属于类的方法,在加载类以后就可以自己调用,不需要创建任何类的实例对象,使用方法:类名.方法名。

如:int abc = Num.getNum();
final:final修饰的类不能再被继承,其修饰的方法也不能被覆盖,而其修饰的变量在初始化后就不允许再修改了。

this:这个有必要重点说一下,乍一看,this是代表当前的意思,是处理局部变量和全局变量的重名,而什么时候使用this呢?当定义类中函数功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象,简单来说,哪个对象在调用this所在的函数,this就代表哪个对象。(this的作用,其实是在类之间相互调用的时候传入某个相同变量名的值时使用)。

class Person
{
private String name;
private int age;
Person(String name)
{
this.name=name;
}
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public void speak()
{
System.out.println("name="+this.name+"..age="+this.age);
show();//省略this.
}
public void show()
{
System.out.println(this.name);
}

public boolean compare(Person p)
{
return this.age==p.age;

}
}
class PersonTest
{
public static void main(String[] args)
{
Person p1=new Person("张三",20);
Person p2=new Person("李四",25);
boolean b=p1.compare(p2);
System.out.println(b);
//Person p = new Person("李四");
//p.speak();
}
}


ac60
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签:  Java 面向对象