---------------------- <ahref="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<ahref="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流! ----------------------
黑马程序员_面向对象基础知识一
面向对象是相对面向过程而言
面向对象和面向过程都是一种思想
面向过程强调的是功能行为
面向对象 将功能封装进对象,强调具备了功能的对象
面向对象将事物简单化了
人开门:名词提炼法
人
{
开门(门)
{
开.门();
}
}
门
{
开(){操作门轴等。}
}
类:就是对现实生活中事物的描述。
对象:就是这类事物,实实在在存在的个体。
类
类是java程序的基本组成单位。
类包含:类声明和类体两部分
类声明即 className
类体又包含:成员变量和成员方法
类声明:
Class:Java语言的关键词,表明这是一个类的定义。
一个类被声明为public,表明该类可以被其他的类访问和引用。如没有则只有与该类定义在同一个包中的类才可以访问这个类
类体:
类体提供了累的对象在生命周期中需要的所有代码:
1构造和初始化新对象的构造方法;
2 表示类及其对象状态的变量;
3实现类及其对象的方法
4进行对象清除的finalize()方法
成员变量:表示类的状态和属性
Private, public ,protected:指定变量的被访问权限
Static指定成员变量为静态变量,其特点是可以直接通过类名访问。如果省略,则表示成员变量为实例变量
public class Apple
{
publicString color;//公共变量color
publicstatic int num;//静态变量 num
publicfinal boolean MATURE = true;//常量MATURE并赋值
publicstatic void main(String[] args)
{
System.out.println("苹果数量:"+Apple.num);
Appleapple = new Apple();
System.out.println("苹果颜色:"+apple.color);
System.out.println("苹果是否成熟:"+apple.MATURE);
}
}
Num是类变量(静态变量),在运行时JVM只为类变量分配一次内存,
并加载类的过程中完成其内存分配,所以可以通过类名直接访问。
Color和MATURE都是实例变量,必须通过创建对象的名称apple实现访问
局部变量:
局部变量作为方法或者语法块的成员,存在于方法的参数的列表和方法体的定义中,局部变量不能使用关键词public ,protected,private和static .可以使用final
Final:可选项,指定该局部变量为常量
面向对象三个特征:封装,继承,多态。
//以后开发:其实就是找对象使用,没有对象,就创建一个对象。
//找对象,建立对象;使用对象。维护对象的关系。
/*
类和对象的关系。
现实生活中的对象:张三 李四。
想要描述:提取对象中共性内容,对具体的抽象。
描述时:这些对象的共性有:姓名,年龄,性别,学习JAVA功能
映射到JAVA中,描述就是class定义的类
具体对象就是对应java在堆内存中用new建立实体
类:就是对现实生活中事物的描述。
对象:就是这类事物,实实在在存在的个体。
*/
//属性对应类中的变量,行为对应类中的函数
//其实定义类,就是在描述事物,就是在定义属性和行为。
//属性和行为共同成为类中的成员变量和成员函数。
/*
成员变量和局部变量
成员变量作用于整个类中
局部变量作用于函数中,或语句中
在内存中的位置
成员变量:在堆内存中,因为对象的存在,才在内存中存在
局部变量:存在栈内存中
*/
// 需求:描述汽车
class Car
{
//描绘颜色
Stringcolor ="红色";
//描述轮胎数
intnum =4;
//运行行为
voidrun
{
System.out.println(color+".."+num);
}
}
class DemoCar
{
publicstatic void main(String[] args)
{
//生产汽车。在java中通过new操作符来完成
//其实就是在堆内存产生一个实体
Carc = new Car ();//c就是一个类类型变量。记住类类型变量指向对象。
//需求:将已有的车的颜色改成蓝色。指挥该对象做使用。在java中指挥方式:对象.对象成员。
c.color= "blue";
c.run();
Carc1 = new Car ();
c1.run();//red4;
}
}
/*
对象一建立就会调用与之对应的构造函数
构造函数的作用:可以用于给对象进行初始化
构造函数的小细节
当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后,默认的构造函数就没有了。
构造函数和一般函数在写法上有不同
在运行上也不同;构造函数在对象一建立就运行。给对象初始化
而一般方法是对象调用才执行,给是对象添加对象具备的功能
一个对象建立,构造函数只能运行一次
而一般方法可以被该对象调用多次
什么时候定义构造函数?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中
*/
class Person
{
privateString name;
privateint age;
/*
构造函数块。
作用:给对象进行初始化
对象一建立就运行,而且优先于构造函数执行
和构造函数的区别
构造代码块是给所有对象进行统一初始化
而构造函数时给对应的对象初始化
构造代码块中定义的是不同对象共性的初始化
*/
{
cry();
}
This
/*
this:看上去,是用于区分局部变量和成员变量同名情况。
this为什么可以解决这个问题呢?
this到底代表着什么呢?
this:就是代表本类的对象,到底代表哪一个?
this代表他所在的函数所属对象的引用
简单说:哪个对象在调用this所在的函数,this就是代表哪个对象
*/
Person(Stringname)
{
this.name= name;//其实和 p.name= name;
}
//需求:给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人
publicboolean compare(Person p)
{
returnthis.age == p.age;
}
//this的应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象
//但凡本类功能内部使用了本类对象,都用this表示。
Person()
{
System.out.println("A:name="+name+",,age="+age);
cry();
}
Person(Stringn)
{
name= n;
System.out.println("B:name="+name+",,age="+age);
cry();
}
Person(Stringn,int a)
{
name= n;
age= a;
System.out.println("C:name="+name+",,age="+age);
cry();
}
publicvoid cry()
{
System.out.println("cry...................");
};
publicvoid setName(String n)
{
name= n;
}
publicString getName()
{
returnname;
}
//this语句:用于构造函数之间进行相互调用。
//this语句只能定义在构造函数的第一行。因为初始化要先执行。
Person(Stringname,int age)
{
this(name);//p(name);
this.age= age;
}
}
class PersonDemo2
{
publicstatic void main(String[] args)
{
Personp1 = new Person();
Personp2 = new Person("lisi");
System.out.println(p2.getName());
p2.setName("wangba");
System.out.println(p2.getName());
Personp3 = new Person("wangyu",10);
}
}
class PersonDemo3
{
}
//匿名对象
new Car().num =5;
new Car().color ="blue";
new Car().run();
//匿名对象使用方式1:当对对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化
//如果对一个对象进行多个成员调用,必须给这个对象起名字
Car c = new Car();
c.run();
//要求:汽车修配厂。对汽车进行改装,将来的车都改成黑色三个轮胎的
main()
{
//Carc = new Car();
//show(c);
show(newCar());//与上面一样,但是简化了
//匿名对象使用方式2:可以将匿名对象作为实际参数进行传递
}
publicstatic void show(Car c)
{
c.num= 3;
c.color= "black";
c.run();
}
//封装
/*
封装:是指隐蔽对象的属性和实现细节,仅对外提供公共访问方式
好处:
将变化隔离
便于使用
提高重要性
提高安全性
封装原则:
将不需要对外提供的内容都隐藏起来
把属性都隐藏,提供公共方法对其访问
*/
/*
Private 私有,权限修饰符:用于修饰类中的成员(成员变量,成员函数)
私有只在本类中有效
将age 私有化以后,类以外及时建立对象也不能直接访问
但是人应该有年纪,就需要在Person类中提供对应访问age的方式
*/
//注意:私有仅仅是封装的一种表现形式。只要权限是访问不到都是封装
//通常需要set和get两种
class Person
{
Privateint age;//出现负数不符合现实;加一个Private
publicvoid setAge(int a)
{
//之所以对外提供访问方式,就是因为可以在访问方式中加入逻辑判断等语句
/对访问的数据进行操作。提高代码的健壮性
if(a>0&& a<130)
{
age= a;
speak();
}
else
System.out.println("feifaage");
}
publicint getAge()
{
returnage;
}
voidspeak()
{
System.out.println("age="+age);
}
}
class PersonDemo
{
publicstatic void main(String[] args)
{
Personp = new Person();
// p.age = -20; age 被私有化无法直接访问
p.setAge(20);
p.getAge();
}
}
//
---------------------- <ahref="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<ahref="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流! ----------------------