-
面向对象:三个特征:封装,继承,多态
面向对象时相对面向过程而言;
面向对象和面向过程是一种思想;
面向过程:强调的是功能行为(动作);按步骤执行,一步一步执行;
面向对象:将功能功能封装进对象,强调具备了功能的对象。将复杂问题简单化。
面向对象是基于面向过程的。
找对象,建立对象,使用对象,维护对象的关系。提高代码的复用性。 -
类和对象的关系:
现实生活中的对象:张三,李四。
想要描述:提取对象中共性内容,对具体的抽象。
描述时:这些对象的共性有:姓名,年龄,性别,学习java功能。映射到java中,描述就是class定义的类。
具体对象就是对应java在堆内存中用new建立的实体。类就是现实生活中事物的描述(属性和行为)。
对象:就是这类事物,实实在在存在的个体。
/*
需求:描述汽车(颜色,轮胎数)。描述事物其实就是在描述事物的属性和行为.
属性对应时类中的变量,行为对应的类中的函数(方法)。
其实定义类,就是在描述事物,就是在定义属性和行为。 属性和行为共同成为类中的成员(成员变量和成员函数)。
*/
public class Car {
//成员变量
//描述颜色
String color = "红色";
//描述轮胎数
int num = 4;
//运行行为
void run()
{
System.out.println(color + ".." + num);
}
}
class CarDemo
{
public static void main(String[] args){
//其实汽车,在Java中通过new操作符来完成。
//其实就是在堆内存生产一个实体
Car c = new Car(); //c就是一个类类型变量。记住类类型变量指向变量。堆内存中的都有默认初始化。
//需求:将已有车的颜色改成蓝色。指挥该对象做使用,在Java指挥方式就是:对象.对象成员
c.color = "blue";
c.run();
//新对象,新车,对象就是类的实例
Car c1 = new Car();
c1.run();
//多个引用指向同一个对象。只有new才产生新的对象
Car c2 = new Car();
c2.num = 5;
Car c2_new = c2;
c2_new.color = "green";
c2.run();
}
}
-
成员变量和局部变量的区别:
作用范围:
成员变量作于整个类中。
局部变量作用与函数中,或者语句块中
在内存的位置:
成员变量:在堆内存中,因为对象的存在, 才在内存中存在,堆内存数据自动默认初始化
局部变量:存在栈内存中,
-
封装:
封装:是指隐藏对象的属性和实现细节,对外提供公共访问方式。
好处:
- 将变化隔离
- 便于使用
- 提高重用性
- 提高安全性
封装原则:
- 将不需要对外提供的内容都隐藏起来
- 把属性都隐藏,提供公共方法对其访问。
/*
private: 私有,权限修饰符:用于修饰类中的成员(成员变量,成员函数)。
私有只有在本类中有效
将age私有化以后,类意以外即使建立了对象也不能直接访问
但是人应该有年龄,就需要在Person类中提供对应访问age的方式
注意:私有仅仅时封装的一种表现形式。
之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句。
对访问的数据进行操作,提高代码的健壮性。
*/
public class Person {
private int age;
public int getAge() {
return age;
}
public void setAge(int a)
{
if(a > 0 && a < 150) {
this.age = a;
speak();
}
else
System.out.println("false age");
}
void speak()
{
System.out.println("age = " + age );
}
}
class PersonDemo
{
public static void main(String[] args) {
Person p = new Person();
p.setAge(-20);
p.speak();
}
}
-
构造函数
特点:- 函数名和类名相同
- 不能定义返回值类型
- 不可以写return 语句
作用:给对象初始化
注意:
- 默认构造函数的特点。
- 多个构造函数是可以以重载的形式存在。
/*
对象一建立就会调用与之对应的构造函数。
构造函数的作用:可以用于给对象进行初始化。
构造函数的小细节:
当一个类中没有定义构造函数时,那么系统就会默认给该类加入一个空参数的构造函数
当类中自定义构造函数后,默认的构造函数就没有了。
构造函数和一般函数在写法上有不同
在运行上也有不同。
构造函数实在对象一建立就运行,给对象初始化
而一般方法时对象在调用才执行,给对象添加对象具备的功能。
一个对象建立,构造函数只运行一次,
而一般方法可以被该对象调用多次。
什么时候定义构造函数?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
*/
public class Person {
private String name;
private int age;
/*
构造代码块:
作用:给对象进行初始化。
对象一建立就运行,而且优先于构造函数执行。
和构造函数的区别:
构造函数代码块是给所有对象进行统一初始化,
而构造函数是给对应的对象初始化
定义所有对象的共性
*/
{
//System.out.println("Peroson code run ")
cry();
}
Person()
{
System.out.println("A: name = " + this.name + ",age = " + this.age);
// cry();
}
Person(String name)
{
this.name = name; //this用于区分成员变量和局部变量
System.out.println("B: name = " + this.name + ",age = " + this.age);
//cry();
}
Person(String name, int age)
{
this(name); //用于构造函数之间相互调用。
this.age = age;
System.out.println("C: name = " + this.name + ",age = " + this.age);
//cry();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void cry()
{
System.out.println("Cry....");
this.show();
}
public void show()
{
System.out.println(this.name);
}
/*
需求:给人定义一个用于比较年龄是否相同的功能,也就是是否时同龄人
*/
public boolean compare(Person p)
{
return this.age == p.age;
}
}
class PersonDemo
{
public static void main(String[] args) {
Person p = new Person();
Person p1 = new Person("Jone");
Person p2 = new Person("Snow", 10);
p.cry();
p.cry();
}
}
-
this
this: 用于区分局部变量和成员变量
this:就代表本类的对象,代表它所在函数所属对象的引用。
简单说:哪个对象在调用this所在的函数,this就代表哪个对象。
如果没有重名的变量,this则可以省略不写。this的应用:当定义类中功能时,该函数内部都要用到调用该函数的对象时,这时用this来表示这个对象。
但凡本类功能内部使用了本类功能, 都要用this表示。this语句:用于构造函数之间相互调用。this(参数)
this语句(初始化要先执行,赋值可以先可以后):只能定义在构造函数的第一行,因为初始化要先执行。
类的执行过程: