黑马程序员_编程基础之第四篇---java面向对象一
01-面向对象概述
1.面向对象概念
面向对象是一种思想，它早期的思想是面向过程。
面向对象是基于面向过程
面向过程---强调的是功能行为。 面向对象---将功能封装进对象，强调具备了功能的对象。
02-面向对象（举例）
面试中可能会遇到
复杂事情简单化，先找对象。
03-面向对象（类与对象的关系）
如人开门：名词提炼法
人
{
开门（门）
{
门.开（）；
}
}
门
{
开（）{操作门轴等；}；
}
面向对象有三个特征：封装、继承、多态 以后开发：其实就是在找对象使用，如果没有对象，就创建一个对象。 找对象、建立对象、使用对象、维护对象之间的关系
类和对象的关系：
现实生活中的对象：张三、李四 ; 想要描述： 提取对象中共性内容，对具体对象的抽象; 描述时：这些对象的共性有：姓名、年龄、性别、学习java功能，这些用类来体现，而不同的对象有不同的姓名、年龄、性别、学习java功能，这些要具体到每个实体；
这些映射到java中，描述就是class定义的类。 具体的对象就是对应java在堆内存中用new建立的实体。
类：对现实生活中事物的描述 ; 对象：这类事物实实在在存在的个体
/*需求：描述汽车（颜色、轮胎数）.描述事物其实就是在描述事物的属性和行为。
属性对应的是类中的变量，行为对应的是类中的函数。
其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员（成员变量和成员函数）。
*/
返回结果：蓝色..4
红色..4
class Car
{
//描述颜色
String color="红色";//显式初始化值
//描述轮胎数
int num=4;
//运行行为--方法
void run()
{
System.out.println(color+".."+num);
}
}
class Dx3
{
public static void main(String[] args)
{
//生产汽车。在java中通过new操作符来完成
//其实就是在堆内存中产生一个实体
Car c=new Car();//c就是一个类类型变量（引用类型）。类类型变量指向对象。
//需求：将已有的车改成蓝色，指挥该对象做使用。在java中指挥方式是：对象.对象成员
c.color="蓝色";
c.run();
Car c1=new Car();//凡是new就是产生一个新对象
c1.run();
}
}
对象的特点在于封装数据。
04-面向对象（成员变量和局部变量）
成员变量和局部变量的不同：
1.作用范围
成员变量作用于整个类中。
局部变量作用于函数中，或者是语句中。
2.在内存中的位置
成员变量：在堆内存中，因为对象的存在，才在内存中存在
局部变量:存在栈内存中
05-面向对象（匿名对象的应用）
new Car();//这是匿名对象
Car c=new Car();//给对象起名c
c.num=5;
//简写格式
new Car().num=5;
new Car().color="blue";
new Car().run();
调用方法匿名对象比较有意义，而调用属性，匿名方法是没有意义的。
//匿名对象使用方式一：
Car c=new Car();
c.run();
c.num=4;
new Car().run();//这种方法只可以调用方法
当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
如果对一个对象进行多个成员调用，必须给这个对象起个名字。
需求：汽车修配厂，对汽车进行改装，将来的车都改成黑色，三个轮胎。
public static void main(String[] args)
{
Car q=new Car();
show(q);
}
public static void show(Car c)
{
c.num=3;
c.color=black;
c.run();
}
}
//匿名对象使用方式二：
可以将匿名对象作为实际参数进行传递。
public static void main(String[] args)
{
Car q=new Car();
show(q);
}
public static void show(Car c)
{
c.num=3;
c.color=black;
c.run();
}
}
比较两者在内存中的不同之处：
06-面向对象（封装概述）
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：1.隔离了变化 2.便于使用 3.提高重用性 4.提高安全性
07-面向对象（封装private）
private:私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）
私有只在本类中有效。
class Person
{
private int age;
void speak()
{
System.out.println("age="+age);
}
}
class Dx6
{
public static void main(String[] args)
{
Person p=new Person();
p.age=20;//age只可以在Person类中访问
p.speak();
}
}
将age私有化以后，类以外即使建立了对象也不能直接访问了，但是人应该有年龄，那么就需要在Person类中提供对应的访问age的方式。
可以在Person中添加一个public方法
public void haha(int a)
{
age=a;
}
在main（）中调用
p.haha(20);这是一种方法；
规范写法：对于age这个变量来说，它的操作方式只有两种set和get。
方法名如果有多个单词组成，那么第一个单词首字母小写，其后的每个单词首字母大写。
一个成员变量通常都会对应两个访问方式，（设置和获取）
private int age;
public void setAge(int a)
{
age=a;
}
public int getAge()
{
return age;
}
注意啦！！注意啦！！！封装不是私有，私有仅仅是封装的一种表现形式。
私有是最小权限!
之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码的健壮性。
public void setAge(int a)
{
if(a>0&&a<130)
age=a;
else
System.out.println("非法age");
}
public int getAge()
{
return age;
}
void speak()
{
System.out.println("age="+age);
}
}
class Dx7
{
public static void main(String[] args)
{
Person p=new Person();
//p.age=20;age只可以在Person类中访问
p.setAge(140);
p.speak();
}
}
封装原则：将不需要对外提供的内容都隐藏起来
把属性都隐藏起来，提供公共方法对其访问。
凡是set开头的方法，返回值都是void，而且带参。
get方法的话，没有参数，返回类型和它获取的变量一致。
凡是带有set。。，get。。方法的，类中肯定有一个私有的成员变量。
成员变量都有一个默认初始值，而局部变量不初始化值是不能参与运算的。
08面向对象（构造函数）
/*构造函数与函数的不同
1.写法
a.函数名与类名相同
b.不需要定义返回值类型
c.不可以写return语句*/
该程序返回结果是：Person run
这里并没有调用函数，但是函数运行了。
证明：对象一建立，就会调用与之对应的构造函数。
构造函数的作用，可以用于给对象进行初始化。
构造函数的小细节：当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数时，系统就不会给你定义了；
class Dx8
{
public static void main(String[] args)
{
Person p=new Person();
}
}
class Person
{
//Person（）{}空参数的构造函数，方便该类初始化，否则对象是建立不出来的
Person()
{
System.out.println("Person run");
}
}
构造函数和一般函数在写法上有不同
在运行商也有不同
构造函数在对象一建立就运行，给对象初始化。
而一般方法是对象调用才执行，给对象添加对象具备的功能。
一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次
什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造函数需不需要未知内容参与运算呢？需要就定义参数，不需要就不定义，这和普通函数是一样的。
class Person
{
private String name;
private int age;
//定义三个构造函数，因为初始化时可能不一样，所以分别定义不同的构造函数对不同的对象进行初始化
Person()
{
System.out.println("name="+name+",,age="+age);
cry();//构造函数中cry(),只会调用一次
}
Person(String n)
{
name=n;
System.out.println("name="+name+",,age="+age);
cry();
}
Person(String n,int a)
{
name=n;
age=a;
System.out.println("name="+name+",,age="+age);
cry();
}
public void cry(0
{
System.out.println("cry");
}
}
class Dx8
{
public static void main(String[] args)
{
//不同的对象调用不同的构造函数
Person p1=new Person();
p1.cry();//一般函数
Person p2=new Person("文君");
Person p3=new Person("哪吒",2);
}
}
问题1：
如果注释了Person()
{
System.out.println("name="+name+",,age="+age);
}
Person p2=new Person("文君");
Person p3=new Person("哪吒",2);
程序返回结果将会是什么呢？
程序返回结果：找不到符号Person();
原因是：在调用对象p1时，它在找空参数的构造函数初始化，可是Person类中没有，因此这个对象是不可能建立的。
09面向对象（构造代码块）
class Person
{
private String name;
private int age;
/*构造代码块
作用：给对象进行初始化。
对象一建立就运行，而且优先于构造函数的执行
构造代码块和构造函数的区别：
构造代码块是给所有对象进行统一初始化。
而构造函数是给对应的对象初始化
构造代码块中定义的是不同对象中共性的内容
*/
{
//System.out.println("Person 构造代码块");
cry();//这样就不需要每个构造函数都调用了，而且它优先于构造函数，构造代码块先执行，再执行构造函数
}
//定义三个构造函数，因为初始化时可能不一样，所以分别定义不同的构造函数对不同的对象进行初始化
Person()
{
System.out.println("name="+name+",,age="+age);
//cry();//构造函数中cry(),只会调用一次
}
Person(String n)
{
name=n;
System.out.println("name="+name+",,age="+age);
//cry();
}
Person(String n,int a)
{
name=n;
age=a;
System.out.println("name="+name+",,age="+age);
//cry();
}
public void cry()
{
System.out.println("cry");
}
}
class Dx9
{
public static void main(String[] args)
{
//不同的对象调用不同的构造函数
Person p1=new Person();
p1.cry();//一般函数
Person p2=new Person("文君");
Person p3=new Person("哪吒",2);
}
}
程序返回结果：
Person 构造代码块
name=null,,age=0
cry
cry
Person 构造代码块
name=文君,,age=0
cry
Person 构造代码块
name=哪吒,,age=2
cry
10-面向对象（this关键字）
Person(String name)//这里的构造函数private了，外界便不能访问，对象是不可能建立成功的
{
name=name;
}
Person(String n,int a)
{
name=n;
age=a;
System.out.println("name="+name+",,age="+age);
}
public void speak()
{
System.out.println("name="+name+",,age="+age);
}
}
class Dx10
{
public static void main(String[] args)
{
Person p=new Person("文君");
p.speak();
}
}
程序返回结果name=null,,age=0
说明：name属于局部变量，name=name；前面的name不是成员变量，因此name赋值不成功。
介绍一种关键字，以便于标识。
this：看上去是用于区分局部变量和成员变量同名的情况
加上this之后，程序运行结果截然不同
Person(String name)//这里的构造函数private了，外界便不能访问，对象是不可能建立成功的
{
//name=name;
this.name=name;
}
Person(String n,int a)
{
name=n;
age=a;
System.out.println("name="+name+",,age="+age);
}
public void speak()
{
System.out.println("name="+name+",,age="+age);
}
}
class Dx10
{
public static void main(String[] args)
{
Person p=new Person("文君");
p.speak();
}
}
程序返回结果name=文君,,age=0
this可以解决这个问题，但是为什么this可以解决这个问题呢？this到底代表的是什么呢？
this的特点：
this就代表的是本类的对象。但是一个类中可以有很多对象，到底代表哪一个呢？
Person(String name)
{
this.name=name;
}
Person p1=new Person("文君");
Person p2=new Person("哪吒");
从这段代码可以看出，this代表的是它所在函数所属对象的引用。
简单地说，哪个对象在调用this所在的函数，this就代表哪个对象，这里的this先后指代p1、p2。
Person(String n)
{
name=n;
System.out.println("name="+name+",,age="+age);
cry();
}
Person(String name)
{
this.name=name;
}
Person(String name,int a)
{
this.name=name;
this.age=age;
}
public void speak()
{
System.out.println("name="+name+",,age="+age);
}
}
class Dx10
{
public static void main(String[] args)
{
Person p1=new Person("文君");
Person p2=new Person("哪吒");
p1.speak();
p2.speak();
}
}
程序运行结果是name=文君,,0
name=哪吒,,0
这是为什么呢？
原因是：public void speak()
{
System.out.println("name="+name+",,age="+age);
}中name指的是this.name,age是this.age,它们分别指代了不同的对象。
函数也是要被对象调用，都省略了this.。只有运行的对象才是this标识的对象。
11-面向对象（this关键字的应用）
this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
但凡本类功能内部使用了本类对象，都用this表示。
class Dx11
{
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);
}
}
//需求：给人定义一个用于比较年龄是否相同的功能，也就是是否是同龄人。
public boolean compare(Person p)//年龄是否相同，返回是或者否，对年龄进行比较
{
return this.age==p.age;//this代表当前对象
}
class Person
{
private String name;
private int age;
Person(int age)
{
this.age=age;
}
Person(String n)//这里的构造函数private了，外界便不能访问，对象是不可能建立成功的
{
name=n;
System.out.println("name="+name+",,age="+age);
cry();
}
Person(String name)//这里的构造函数private了，外界便不能访问，对象是不可能建立成功的
{
name=name;
}
Person(String n,int a)
{
name=n;
age=a;
System.out.println("name="+name+",,age="+age);
}
public void speak()
{
System.out.println("name="+name+",,age="+age);
}
}
12-面向对象（this关键字在构造函数间调用）
class Person
{
private String name;
private int age;
Person(String name)
{
this.name=name;
}
Person(String name,int a)
{
//this.name=name;这个动作上面已经做过了
Person(name);//普通函数中这样就可以直接调用了，但是这是构造函数调用
this（name）；//this语句
this.age=age;
}
}
this语句：用于构造函数之间互相调用，只能用this语句。
this语句只能放在构造函数的第一行，初始化动作要先执行
class Person
{
private String name;
private int age;
Person(String name)
{
this.name=name;//3
}
Person(String name,int a)//2
{
//this.name=name;这个动作已经做过了
//Person(name);普通函数中这样就可以直接调用了，可是构造函数中时不被允许的，要用this（name）
this(name);//p(name);1--name传了3次
this.age=age;
}
}
class Dx12
{
public static void main(String[] args)
{
Person p=new Person("lisi",30);
}
}
this的用法：
1.用于区分同名变量
2.this不能用于一般函数，只能用于构造函数中
3.this应用
