黑马程序员-----java面向对象

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

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

类和对象的关系：类是抽象的，对象是具体的一个事物的描述，一个类包含多个对象。例如：动物类，它就包含狮子，老虎，大象等对象。

一个类的组成：属性对应类中的变量，行为对应类中的函数和方法。

成员变量和局部变量的区别：。

作用范围。

成员变量作用于整个类中。

局部变量变量作用于函数中，或者语句中。

在内存中的位置：

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

局部变量：存在栈内存中。

下面对类和对象的使用，以及它们之间的关联进行一下代码演练：

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();//red 4;

//      Car c = new Car();
//      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();
*/

Car q = new Car();
show(q);

//show(new Car());
}

//需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。
public static void show(Car c)
{
c.num = 3;
c.color = "black";
c.run();
}
}

———-上面这段代码，实际上就是先创建了一个汽车类，然后创建汽车类的对象，给汽车类的属性重新赋值，然后调用其动作方法，由此可以看出对象可以使用类的方法，也可以对其属性重新赋值，产生一个独立的对象。

上面代码中我们使用到了匿名对象，什么是匿名对象呢，顾名思义就是没有名称的对象，实际项目中如果这个对象我们只调用一次，那么我们可以把它声明为匿名对象。

匿名对象的使用方式：

匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。

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

一.封装

封装就是隐藏事物具体的实现细节，常见的封装方式就是把类的属性和函数定义为私有的private ，而后提供特有的访问方法，如属性的set和get方法。

package cn.itheima;

class
c922
User {
private String name;//姓名
private int age;//年龄
/*
* 声明代参构造函数
*/

public void show(){
System.out.println("他叫"+name+"今年"+age);
}
/*
* set方法用来给属性赋值， get和使用属性
*/
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 class Test9{
public static void main(String[] args) {
User user=new User();
user.setName("小明");
user.setAge(18);
user.show();

}
}

———-从上面的代码，我们发现是通过对象点属性的set方法给属性赋值，而后调用函数，通过对象直接点属性名是点不出什么的，那是因为我们把它定义成私有的了，只能通过set和get方法进行访问。

构造函数，每个类对默认有一个无参的构造函数，当我们创建对象时就会默认调用对象的无参构造函数，无参构造函数我们创建对象会默认调用，我们就不演示了，下面我们对有参构造函数进行代码示例演示：

package cn.itheima;

class User {
private String name;//姓名
private int age;//年龄
/*
* 声明代参构造函数
*/
public User(String name,int age){
this.setName(name);
this.setAge(18);
}
public void show(){
System.out.println("他叫"+name+"今年"+age);
}
/*
* set方法用来给属性赋值， get和使用属性
*/
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 class Test9{
public static void main(String[] args) {
User user=new User("小明",18);
user.show();//调用输出方法

}
}

———-这段代码和上面的代码输出结果是一样的，代码几乎没什么大的改动，只是我们这次在创建对象的同时调用类的有参构造方法，直接给属性赋值并输出。

下面我们对构造函数进行总结：对象一建立就会调用与之对应的构造函数。

构造函数的作用：可以用于给对象进行初始化。

构造函数的小细节：

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

当在类中自定义了构造函数后，默认的构造函数就没有了。

构造函数和一般函数在写法上有不同。

在运行上也有不同。

构造函数是在对象一建立就运行。给对象初始化。

而一般方法是对象调用才执行，给是对象添加对象具备的功能。

一个对象建立，构造函数只运行一次。

而一般方法可以被该对象调用多次。

什么时候定义构造函数呢？

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

二.继承

通过extends关键字可以实现继承，父类修饰符如果是public,则该类在整个项目中可见，若无public修饰符，则该类只能在当前包可见，不可以使用private和protected修饰类。

子类可以继承父类public和protected修饰的属性和方法，无论它们是否在一个包里面。可以继承默认权限修饰符（friendly）修饰的属性和方法，前提是它们必须在同一个包里。

子类无法继承private修饰的属性和方法，无法继承父类的构造方法。

子类可以使用super关键字调用父类的构造方法，属性和方法。

子类可以重写父类的方法，重写涉及到方法名和参数列表以及返回值类型相同（或是其子类），访问修饰符不能严于父类。

super关键字代表对当前对象的直接父类对象的默认引用，它无法访问父类private成员。

.抽象类和抽象方法用abstract修饰，抽象类不能实例化，抽象类可以没有，有一个或多个抽象方法，甚至全部方法都可以是抽象方法。抽象方法只有声明，没有方法体，有抽象方法的类必须为抽象类，子类必须重写所有的抽象方法才能实例化，除非子类也是一个抽象类。

用final修饰的类不能被继承，修饰的变量为长量，修饰的方法不能被重写。

abstract可以用来修饰类和方法，不能用来修饰属性和构造方法。Final可以用来修饰类，方法属性，不能用来修饰构造方法。

———-一下子总结了这么多有关于继承的知识：其实实际操作中并没有我们想象中的那么复杂，代码示例如下：

/*
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。

员工类：name id pay

经理类：继承了员工，并有自己特有的bonus。

*/

class Employee
{
private String name;
private String id;
private double pay;

Employee(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}

public abstract void work();

}

/*
经理类

*/

class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println("manager work");
}
}

class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("pro work");
}
}

class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

继承的好处

提高了代码的复用性。

让类与类之间产生了关系。有了这个关系，才有了多态的特性。

注意：

java中只支持单继承，也就是一个类只能继承一个父类

千万不要为了获取其他类的功能，简化代码而继承。

必须是类与类之间有所属关系才可以继承。所属关系 is a。

三.多态

多 态★★★★★（面向对象特征之一）：函数本身就具备多态性，某一种事物有不同的具体的体现。

体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提：

1：必须要有关系，比如继承、或者实现。

2：通常会有覆盖操作。

多态的出现思想上也做着变化：以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。

class 毕姥爷{
void 讲课(){
System.out.println("企业管理");
}
void 钓鱼(){
System.out.println("钓鱼");
}
}
class 毕老师 extends 毕姥爷{
void 讲课(){
System.out.println("JAVA");
}
void 看电影(){
System.out.println("看电影");
}
}
class {
public static void main(String[] args) {
毕姥爷 x = new 毕老师(); //毕老师对象被提升为了毕姥爷类型。
//      x.讲课();
//      x.看电影();  //错误.
毕老师 y = (毕老师)x; //将毕姥爷类型强制转换成毕老师类型。
y.看电影();//在多态中，自始自终都是子类对象在做着类型的变化。
}
}

如果想用子类对象的特有方法，如何判断对象是哪个具体的子类类型呢？

可以可以通过一个关键字 instanceof ;//判断对象是否实现了指定的接口或继承了指定的类

格式：<对象 instanceof 类型> ，判断一个对象是否所属于指定的类型。

Student instanceof Person = true;//student继承了person类

多态在子父类中的成员上的体现的特点：

1，成员变量：在多态中，子父类成员变量同名。

在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）

运行时期：也是参考引用型变量所属的类中是否有调用的成员。

简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。

再说的更容易记忆一些：成员变量 — 编译运行都看 = 左边。

2，成员函数。

编译时期：参考引用型变量所属的类中是否有调用的方法。

运行事情：参考的是对象所属的类中是否有调用的方法。

为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。

简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。

更简单：成员函数 — 编译看 = 左边，运行看 = 右边。

3，静态函数。

编译时期：参考的是引用型变量所属的类中是否有调用的成员。

运行时期：也是参考引用型变量所属的类中是否有调用的成员。

为什么是这样的呢？因为静态方法，其实不所属于对象，而是所属于该方法所在的类。

调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。