黑马程序员_面向对象思想

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

构造函数

构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

 

一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要函数功能时才调用。 

构造函数：对象创建时，会调用只调用一次。

一般函数：对象创建后，可以被调用多次。

static关键字

1，static是一个修饰符，用于修饰成员。

2，static修饰的成员被所有的对象所共享。

3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。 

4，static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。

5，static修饰的数据是共享数据，对象中的存储的是特有数据。

 

成员变量和静态变量的区别？

1，两个变量的生命周期不同。

成员变量随着对象的创建而存在，随着对象的被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

 

2，调用方式不同。

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

 

3，别名不同。

成员变量也称为实例变量。

静态变量称为类变量。 

 

4，数据存储位置不同。

成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.

静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

静态使用的注意事项：

1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)

2，静态方法中不可以使用this或者super关键字。

3，主函数是静态的。

继承相关

不能多继承的原因是由于多继承可能导致调用方法的不确定行，所以接口可以多继承，因为接口不可能存在方法体

1、什么是重载

重载：同一个类中,函数名相同,参数不一样

2、什么是覆盖

覆盖：子类中的函数名和参数名都与父类中相同

覆盖注意点：

2.1、子类函数覆盖父类函数,子类权限必须要大于等于父类权限。

2.2、覆盖并不是把父类中的方法清除掉了。子类实例中开辟的内存空间中有2个show方法，一个show的引用所属为this,一个为super。

2.3、静态只能覆盖静态,或被静态覆盖。

2.4、覆盖只会出现在成员方法中，而不会出现在成员变量中。

2.5、构造函数不能被继承

覆盖细节：

子类构造对象时,发现，访问子类构造函数时，父类也运行了，原因是在子类的构造函数中第一行有一个默认的隐试语句：super()。

子类中所有的构造函数默认都会访问父类中空参的构造函数。

为什么子类实例化的时候要访问父类中的构造函数呢？

那是因为子类继承了父类，获取到了父类中属性，所以在使用父类属性之前，必须先看看父类是如何对自己的属性进行初始化的。注意：super()语句必须要定义在子类构造函数的第一行。

在子类中的构造函数中若要调用this()，该代码也必须放在第一行。例如：

<pre name="code" class="java"><span style="font-size:15px;">class Fu{
	int num;
	Fu(){
		num = 11
		system.out.println(“num”);
	} 
}
 
class Zi extends Fu{
	Zi(){
	super();
}
Zi(int x){
		this();//表示调用当前类的空参构造函数,当写上这行代码后，就没有默认的super()，这行代码了
		system.out.println(“A”);
	}
}</span>

怎么禁止继承：final关键字

final修饰的类不可以被继承

final修饰的方法不可以被覆盖

final修饰的变量是一个常量，只能被赋值一次

final是显示初始化，所以必须要给一个值，成员加了final后一般会加static。

常量所有字母都大写

final int number = 9//为什么不直接用9，因为可以有个变量名

抽象

特点：

1.方法只能有声明没有实现，需要被abstract，抽象方法必须定义在抽象类中，并且抽象方法不能有方法体。

2.抽象类不可以被实例化。

3.抽象类的子类必须实现其类的所有抽象方法，否则其子类也需要被abstract关键字修饰。

细节：

1.抽象类中是有构造函数的，因为可以给子类初始化。

2.抽象类可以不定义抽象方法，但一般以该形式存在例如：

abstract class Demo{

void show1(){};

void show2(){};

}

为什么要这样存在，目的是父让该类创建对象。

3.抽象关键字不能和那些关键字共存？

private、final、static

接口

它的由来，当抽象类中的所有的方法都为抽象时，那么就可以把还类定义为接口。

接口中常见的成员，而且这些成员都有固定的修饰符：

全局常量：public static final int NUM = 4;

抽象方法：public abstract void show1();

固定的修饰符就是全局常量你不写static，它会默认的加上static，不写final会默认给你加上fianl。

一个类可以继承多个接口

接口与接口之间是继承关系而且接口可以多继承.

抽象类和接口的区别：

 

1：抽象类只能被继承，而且只能单继承。 

接口需要被实现，而且可以多实现。  

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。 

接口中都有抽象方法，需要子类去实现。

3：抽象类使用的是  is a 关系。 

接口使用的 like a 关系。 

4：抽象类的成员修饰符可以自定义。 

接口中的成员修饰符是固定的。全都是public的。    

 

多肽

函数多肽体现在函数名相同参数名不同

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

 

多肽时成员的特点：

code:

class Animal{

int num = 3;

};

class Cat extends Animal{

int num = 4;

}

Animal a = new Cat//体现了多肽，既有动物形态也有猫的形态，a实例只能调用Animal中的成员方法，而不能调用Cat类中的成员方法。自动类型提升

system.out.print(a.num);//3

Cat cat = (Cat)a //向下转型

成员变量：编译时，若Animal对象中不存在num属性那么调用a.num会出错。运行和编译时都参考等号左边的

成员函数：编译时参考等号左边，运行时参考等号右边。

多肽的好处：提高了代码的复用性，前期定义的代码可以使用后期的内容。

多肽的弊端：前期定义的内容不能调用后期子类特有的内容。

多态的前提： 必须要有关系，比如继承、或者实现。

1、匿名内部类

匿名内部类：没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。 

 

匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

 

匿名内部类的使用场景：

当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。

其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。

 

2、类中的内部类

在类里面定义的类称之为内部类（Inner Class），内部类是外部类的一个成员。

内部类必须创建外部类对象才能使用。

创建内部类对象时必须先创建一个外部类对象，通过一个外部类对象才能创建内部类对象。

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

内部类可以直接访问外部类的成员，而外部类不能直接访问内部类的成员。访问方式：外部类名.this.成员名

内部类可以访问外部类成员，因为在使用内部类时一定会有外部类对象，且只对应一个。

外部类不能访问内部类成员，因为在使用外部类时有可能还没有创建内部类对象。

如果一定要在外部类中使用内部类成员，那么需要创建内部类对象，通过对象来访问。

内部类中不能定义静态成员。

因为内部类需要创建外部类对象才能使用，static的本意是不创建对象就能使用，这是矛盾的。

 

内部类的class文件名为：外部类名.内部类名.class

 

3、方法中的内部类

一个类如果只在某个方法中使用，那么可以在方法中定义。

定义在方法中的类只能在方法中使用，而且使用的代码只能在声明的代码下面。

方法中的内部类只有在运行到类定义之后才能使用。

方法中定义的内部类不能访问方法中定义的局部变量，除非这个局部变量被声明为final的。

在方法中定义的局部变量在方法运行结束之后生命周期结束，不能再被访问。

方法中的内部类创建的对象有可能生命周期比这个局部变量长，例如这个对象被作为返回值返回，那么方法运行结束之后还可以访问这个对象。

这时变量被销毁了，对象还在，如果在对象的某个方法内访问这个变量就访问不到了。

我们需要使用final修饰这个变量，被final修饰的变量会一直存储在内存中，方法运行结束之后不被销毁。

方法中的内部类class文件名为：外部类名$.编号内部类名.class

 

4、静态内部类

可以使用static修饰一个类中的内部类。

静态内部类不用创建外部类对象就可以直接创建对象。

外部类名.内部类名 变量名 = new 外部类名.内部类名();

静态内部类可以定义静态成员。

因为静态内部类可以直接使用，无需创建外部类对象。

静态内部类中不能访问外部非静态成员。

因为创建静态内部类不需要外部类对象，也就是有可能没有创建外部类对象，使用外部类成员必须有外部类对象。

class Outer{

default class Inner{}

}

//实例化内部内的格式

Outer.Inner = new Out().new Inner

*****************************************************

class Outer{

private class Inner{}

}

//实例化内部内的格式

Outer.Inner = new Out.Inner();

 

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------