一、什么是面向对象
面向对象和面向过程的异同点:
相同点:都是一种思想,编程思想。
不同点:面向过程------>强调的是功能行为,即注重完成每件事情的每一个步骤;
面向对象-------->强调的是具备了某一功能的对象,把完成某个功能的特定步骤封装起来,然后再调用。
举一个简单而又形象的例子:实现把大象装进冰箱
面向过程的的实现:
第一步:把冰箱门打开
第二步:把大象装进冰箱里
第三步:关上冰箱门
一步一步的来实现即可
面向对象的实现:
分析:有哪些对象? 大象、冰箱。
对象的特点、功能等------------>如冰箱这个对象应该有存储、打开关闭等功能等功能
冰箱.打开();
冰箱.存储(这里是把 大象传进来);
冰箱.关闭();
由此可见:面向对象是把实现的功能封装了然后再去调用即可
类的概念
java程序中的class:类的意思,每一个class就是一个类,类是一种数据类型而且是引用数据类型
程序中类是用来创建对象的,属于概念模型;然而对象是实实在在的个体,即对象是类的实例。
类与对象就好像设计图纸与产品一样:
类的作用:用来描述和创建对象,类描述的是对象的属性和行为:
属性:事物身上的名词--------------------->对应程序中用变量来表示
行为:事物身上的动词---------------------->对应程序中用方法来表示
java中最基本的单位是类 在类中描述事物时的相关概念如下:
(1).成员:java中在类中方法外定义的变量和各种方法都叫类中的成员
(2).成员变量:在class 即类中方法外定义的变量
(3).局部变量:在方法中、for循环的“()”里以及循环体内定义的变量都是局部变量
(4).变量的作用域:变量从被定义的位置开始,到其所在的花括号"{ }"结束
(5).方法的调用:在同一个类中时格式:方法名(参数列表);
在不同的类中:通过创建某个类的对象来调用该类的方法
举例:例1 创建一个车类
属性:车轮数为4、颜色为红色、价格30万
行为:行驶
class Car//定义了一个车类
{
int num;//定义属性
double price;
String color;
public void run()//定义行为
{
System.out.println("行驶");
}
}
class Demo_1
{
public static void main(String[] args)//main函数:程序运行的入口
{
Car car=new Car();//创建Carl类的对象car
car.num=4;//通过对象car访问其属性并进行赋值
car.color="红色";
car.price=300000.0;
System.out.println(car.num+","+car.color+","+car.price);//输出对象car的属性值
car.run();//通过对象car调用其方法
}
}
二、类的加载和对象的内存分配
java程序在运行时jvm即java虚拟机会把他所管理的内存划分为:
栈、堆、方法区、本地方法区和寄存器这五个区域
在执行上述程序时java虚拟机 (JVM) 先找到程序运行的入口即找到main函数,此时main
函数入栈并且为变量car在栈中开辟内存;与此同时把Demo_1.class 文件加载到方法区。
使用Car创建对象时把Car.class 文件加载到方法区,接着在堆中为对象开辟内存及为成员
变量开辟内存;通过对象car访问属性并进行初始化后 接着打印出属性值;最后通过对象car
调用run()函数 此时run函数要入栈。当执行完run函数时返回到函数调用的位置,此时main函数
执行完毕;最后run函数先出栈然后main函数再出栈。函数出栈立马释放内存;然而堆中的对象
需要等到垃圾回收线程回收。
知识补充:成员变量和局部变量的区别
1.在类中位置不同:成员变量定义类里面,方法的外部;局部变量定义在方法内
2.存储位置:成员变量在堆中开辟内存(成员变量属于对象,对象进堆内存),
局部变量在栈开辟内存(局部变量属于方法,方法进栈内存)。
3.作用范围:局部变量的作用范围从其被定义的位置开始到其所在的花括号结束
成员变量的作用范围是整个类。
4.生命周期不同:成员变量随着对象的创建而存在,随着对象的消失而消失;
局部变量随着方法的调用而存在,随着方法的调用完毕而消失。
5.初始化值:局部变量没有默认初始化值,必须定义,赋值 然后才能用;
成员变量有默认初始化值。
构造函数
什么是构造函数?
构造函数也叫构造器,是用来创建对象并给对象初始化用的。注意:是用来创建对象且只能
用于创建对象。
格式:1.无参构造函数
类名 ( ) { }
2.带参数的构造函数
类名 (参数类型1 参数1, 参数类型2 参数2......,参数类型n 参数n)
{
成员变量(属性)1 = 参数名1;
成员变量(属性)2 = 参数名2;
}
构造函数的特点
(1).函数名和类名相同
(2).没有返回值类型,就连void也不能有。
(3).访问权限修饰符可以省略
(4).没有具体的返回值 即没有return
注意:在创建对象时当自己写了构造方法 那么jvm将不再给你提供无参的构造方法了
如果想要写有参构造,那么无参构造也写上;有参构造只是多了一种对成员变量的赋值方式
带参数的构造函数使用举例:
例1.将上面的例子改为带参数的构造方法的形式
class Car//定义了一个车类
{
int num;//定义属性
String color;
double price;
Car(int x,String y,double z)
{
num=x;
color=y;
price=z;
}
public void run()//定义行为
{
System.out.println("行驶");
}
}
class Demo_2
{
public static void main(String[] args)//main函数:程序运行的入口
{
Car car=new Car(4,"红色",300000.0);//创建Carl类的对象car并进行初始化
System.out.println(car.num+","+car.color+","+car.price);//输出对象car的属性值
car.run();//通过对象car调用其方法
}
}
例2.创建一个人 (person) 类
属性:年龄、性别、名字
行为:吃饭
并实例化2 个person对象;
class Person//定义了一个Person类
{
int age;//定义属性
String sex,name;
Person(int nianling,String xingbie,String mingzi)//带参数的构造方法
{
age=nianling;//给属性赋值
sex=xingbie;
name=mingzi;
}
public void eat()//行为 eat方法
{
System.out.println("吃饭");
}
}
class Demo_3
{
public static void main(String[] args)
{
Person per1=new Person(23,"男","张三");//创建对象
System.out.println(per1.age+","+per1.sex+","+per1.name);//输出属性值
Person per2=new Person(27,"男","王二");
System.out.println(per2.age+","+per2.sex+","+per2.name);
}
}
三、封装的体现------------>private关键字
面向对象有三大特点:继承、封装、多态
封装:只对外界提供有用的属性和行为
广义:类和方法定义本身就是封装的体现
关键字:private :私有的-------->称为访问权限修饰符
使用 private 封装类的属性:先将属性定义为private (私有的),再对其属性定义相应的
set方法和get方法
举例:创建一个学生类 Student
属性:年龄、名字
行为:学习
class Student
{
private int age;//定义属性并将其私有化
private String name;
public void setAge(int nianling)//对年龄赋值的setAge方法
{
if(nianling>40 && nianling<60)
System.out.println("不是学生是上班族");
else if(nianling<1 || nianling>130)
System.out.println("年龄不合法");
else
age=nianling;
}
public int getAge()//获取年龄的 getAge方法
{
return age;
}
public void setName(String mingzi)
{
name=mingzi;
}
public String getName()
{
return name;
}
public void study()
{
System.out.println("学习");
}
}
class Demo_4
{
public static void main(String[] args)
{
Student stu=new Student();//创建对象
stu.setAge(22);//通过对象stu 访问成员函数
stu.setName("李欢欢");
System.out.println(stu.getAge()+","+stu.getName());
}
}
小结:封装的好处
(1).提供公共的访问方式,隐藏了实现细节
(2).提高了代码的安全性
(3).提高了代码的复用性
四、this关键字------------>指向当前对象
this的使用:this是一个引用,总是指向当前对象。
this在构造函数中的作用:当局部变量和成员变量同名时,用于区分成员变量。
class Worker
{
private int age;//定义属性并将其私有化
private String name;
public void setAge(int age)//对年龄赋值的setAge方法
{
if(age<1 || age>130)
System.out.println("年龄不合法");
else
this.age=age;
}
public int getAge()//获取年龄的 getAge方法
{
return age;
}
public void setName(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
public void work()
{
System.out.println("work");
}
}
class Demo_4
{
public static void main(String[] args)
{
Worker wor=new Worker();//创建对象
wor.setAge(40);//通过对象stu 访问成员函数
wor.setName("李四");
System.out.println(wor.getAge()+","+wor.getName());
wor.work();
}
}
本例中如果没有用 this 则输出结果会是
0,null
work
这是因为成员变量和局部变量同名,成员变量无效了;所以成员变量根本没有得到初始化。