黑马程序员_Java基础_面向对象(概述、类与对象关系、成员变量、封装private、构造函数和构造代码块、this关键字)

-------
android培训、java培训、期待与您交流！ ----------

一、面向对象（类和对象的关系）

面向对象的三个特征：封装，继承，多态。

以后开发：找对象，建立对象，使用对象，维护对象的关系。

类和对象的关系：类是对象的抽象，对象是类的具体实现。

现实生活中的对象：张三，李四。

描述：提取对象中的共性内容。对具体的抽象。

描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。

映射到java中，描述就是class定义的类。

集体对象就是对应java在堆内存中用new建立的实体。

类就是对现实生活中事物的描述。

对象就是这类事物，实实在在存在的个体。

/*
定义一个简单的汽车类
*/

class Car
{
String color="蓝色";//定义颜色
String name="奔驰";//定义品牌
int num=4;//定义轮胎数

void run()
{
System.out.println("品牌："+name+"\n颜色:"+color+"\n轮胎数："+num);
}
}

class  CarDemo
{
public static void main(String[] args)
{
Car c=new Car();//在堆中产生一个实体（汽车）。在栈中产生Car类型c变量并指向实体。
c.color="红色";//更改对象c的color属性的值为"红色"。
c.run();//调用对象c的run()方法。
}
}

二、面向对象（成员变量和局部变量）

作用范围：

成员变量作用于整个类中，局部变量作用于函数中或者语句中。

成员变量：在堆内存中，因为对象的存在，才在内存中存在。

局部变量：在栈内存中。

三、面向对象（匿名对象）

例如：

new Car().num=5;

new Car.run();

这样并没有指明对象的名称（也就是引用）。

匿名对象使用方式1：当对象的方法值调用一次，可以用匿名对象，这样比较简化。

如果对一个对象进行多个成员调用，必须给这个对象起名字。

匿名对象使用方式2：可以将匿名对象作为实际参数进行传递。

四、面向对象（封装）

概念：是隐藏对象的属性和方法的实现细节。

/*
Private访问修饰符
*/
class Person
{
private String name="杨成";
private int age=18;

public void setAge(int a)//设置age函数
{
if(a>0&&a<300)
{
age=a;
}
else
System.out.println("修改年龄错误！");
}
public int getAge()//获得age
{
return age;
}
void display()//没写修饰符，表示默认。可以被同包不同类访问。
{
System.out.println("name:"+name+"\nage:"+getAge());
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p=new Person();

//p.age=30;  //不能在Person类外访问其私有成员属性
p.setAge(21);
p.display();

}
}

五、面向对象（构造函数）

作用：用来初始化对象的成员变量。

注意：

1. 与类名同名

2. 没有返回值类型

3. 不可写return语句

提醒：同名构造函数通过形参的类型和形参的数目进行区分。

当一个类中没有定义构造函数时，系统会默认向类加入一个空参数的构造函数。

构造函数是在对象已建立就运行，给对象初始化。而类里面的一般函数是对象经过调用执行的。

一个对象建立构造函数只执行一次。而里面的一般函数可被该对象调用多次。

/*
构造函数
*/
class Person
{
private String name="杨成";
private int age=18;

Person()//不带参数构造函数
{
System.out.println("不带参数构造函数\n"+"name:"+name+"\nage:"+age);
}

Person(String n)// 带一个参数构造函数
{
name=n;
System.out.println("带一个参数构造函数\n"+"name:"+name+"\nage:"+age);
}
Person(String n,int a)// 带两个参数构造函数
{
name=n;
age=a;
System.out.println("带两个参数构造函数\n"+"name:"+name+"\nage:"+age);
}
void display()
{
System.out.println("name:"+name+"\nage:"+age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p1=new Person();//采用不带参数构造函数初始化
Person p2=new Person("张三");//采用带一个参数构造函数初始化
Person p3=new Person("张三",22);//采用带两个参数构造函数初始化

//p.age=30;  //不能在Person类外访问其私有成员属性
//System.out.println();//换行
p1.display();
p2.display();
p3.display();

}
}

六、面向对象（构造代码块）

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象分别初始化。

/*
构造代码块
*/
class Person
{
private String name="杨成";
private int age=18;

{
System.out.println("构造代码块。");
}

Person()
{
System.out.println("不带参数构造函数\n"+"name:"+name+"\nage:"+age);
}

Person(String n)
{
name=n;
System.out.println("带一个参数构造函数\n"+"name:"+name+"\nage:"+age);
}
Person(String n,int a)
{
name=n;
age=a;
System.out.println("带两个参数构造函数\n"+"name:"+name+"\nage:"+age);
}
void display()
{
System.out.println("name:"+name+"\nage:"+age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p1=new Person();//采用不带参数构造函数初始化
Person p2=new Person("张三");//采用带一个参数构造函数初始化
Person p3=new Person("李四",23);//采用带两个参数构造函数初始化
System.out.println();//换行
p1.display();
p2.display();
p3.display();

}
}

七、面向对象（this关键字）

this就是本类的对象，用来区分同名变量的。

/*
this关键字
*/
class Person
{
private String name="杨成";
private int age=18;

Person(String name)
{
this.name=name;//出现同名name，用this指定本类对象。
System.out.println("带一个参数构造函数\n"+"name:"+this.name+"\nage:"+this.age);
}
Person(String name,int age)
{
this.name=name;//出现同名name，用this指定本类对象
this.age=age;//出现同名age，用this指定本类对象
System.out.println("带两个参数构造函数\n"+"name:"+this.name+"\nage:"+this.age);
}
void display()
{
System.out.println("name:"+name+"\nage:"+age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p1=new Person("张三");//采用带一个参数构造函数初始化
Person p2=new Person("李四",22);//采用带两个参数构造函数初始化

System.out.println();//换行
p1.display();
p2.display();
}
}

八、面向对象（this关键字的应用）

/*
给人定义一个用于比较年龄是否相同的功能。
*/
public boolean compare(Person p)//判断功能代码
{
return this.age==p.age;/*先逻辑判断，在返回逻辑值。
this.age表示本类的age,
p.age表示传递其它对象的age.

*/
}

九、面向对象（this关键字在构造函数间调用）

this语句用于构造函数之间进行互相调用。

this语句只能定义在构造函数的第一行。因为初始化要先执行。

/*
this关键字在构造函数间的调用
*/
class Person
{
private String name;
private int age;

Person()
{

}
Person(String name)
{
this();
this.name=name;
}
Person(String name,int age)
{
this(name);
this.age=age;
}
public void display()
{
System.out.println("name:"+this.name+"\nage:"+this.age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p=new Person("李四",30);
p.display();
}
}

　　-------
android培训、java培训、期待与您交流！ ----------　　详细请查看：http://edu.csdn.net/heima/