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

最新推荐文章于 2022-08-11 00:27:29 发布

原创最新推荐文章于 2022-08-11 00:27:29 发布 · 346 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#黑马程序员

java基础专栏收录该内容

13 篇文章

订阅专栏

本文详细介绍了Java面向对象的高级特性，包括静态成员与方法、单例设计模式、继承与多态等概念，并探讨了它们的使用场景及注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

　------- <a href="http://www.itheima.com"target="blank">android培训</a>、<a href="http://www.itheima.com"target="blank">java培训</a>、期待与您交流！ ----------

面向对象：

一．Static

1. 静态修饰符，修饰成员

1.1 特点：随着类的加载而加载，生命周期最长

被对象所共享，优先于对象存在

成员被静态修饰后，除了可以被对象调用外，还可以被所属类名直接调用

1.2 使用：静态方法只能访问静态成员（变量，方法）

非静态方法可以访问非静态，静态成员。因为静态先于对象存在，所以静态方法中也不可以出现this关键字。

1.3 好处：1.对象的共享数据进行单独空间的存储，节省空间

2.可以直接被类名调用

1.4 弊处：1.生命周期长，内存消耗大

2.访问出现局限性（只能访问静态）

1.5 什么时候使用静态：

* 静态变量（类变量）：当对象出现共享数据时（值），该数据被静态修饰

* 静态函数：当功能内部没有访问到非静态数据，该功能定义成静态。

2.静态的应用---------工具类

（定义工具类的概念用到静态的思想）

可以把一些程序都拥有的共性的功能进行抽取，独立封装成一个功能类，以便使用。

当需要使用这些类封装好的方法时，直接用类名调用即可，不需要创建对象。同时为了避免其他程序创建该工具类对象，需将工具类中的构造方法私有化。

3.静态代码块

Static

{

代码

}

特点：静态代码块：随着类的加载而只执行一次。用于给类进行初始化，优先于主函数执行

（构造代码块：给对象初始化

构造函数：给对应对象初始化）执行优先顺序一次递减

二．单例设计模式

当需要将事物的对象保证在内存中唯一时，就可以用到单例设计模式。

思想：1.为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象

解决：将构造函数私有化

2.（自己建立对象）还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象

解决：在类中创建一个本类对象。

3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

解决：提供一个方法可以获取到该对象。

代码示例：

<span style="font-size:18px;">class Single
{  //三部曲
    privateSingle(){}
    private Single s = newSingle();
    public static SinglegetInstance()
{
return s;
}
}//饿汉式，即先初始化对象（Single类一进内存，就已经创建好对象）</span>

<span style="font-size:18px;">class Single
{  //三部曲
    private Singles=null; 
private Single (){}
 
    public static SinglegetInstance()
{
   if(s==null)
      s = new Single();
return s;
}
}//懒汉式（对象的延时加载），即对象是方法被调用时才初始化（Single类进内存，对象还未存在，只有调用了getInstance()方法时，才建立对象）</span>

注：对于事物应该如何描述就如何描述，当需要将该事物的对象保证在内存中唯一时，就将以上三步加上即可。否则单纯定义如上三步没有意义。

<span style="font-size:18px;">class SingleDemo
{
        public static void main(String[]args)
              {
                    Single ss = Single.getInstance();
              }
}</span>

三．继承与实现（类与接口）强调内容

单继承与多实现：多继承容易带来安全隐患，当多个父类中定义了相同的功能，当功能内容不同时，子类对象不确定要运行哪一个。但java保持这种机制，用多实现来完成。

原则：1.不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承。

2.基本功能定义在类中，扩展功能定义在接口中

四．多态

在多态（父类的引用指向子类对象）中成员(非静态)函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有，编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

总结：成员函数在多态调用时，编译看左边，运行看右边。

（开发中不常见）

在多态中，成员变量的特点：无论编译还是运行，都参考左边（引用型变量所属的类）。

静态成员函数的特点：无论编译还是运行，都参考左边。

五．内部类

什么情况下定义内部类？

当描述事物时，事物的内部还有事物，该事物用内部类描述，因为内部事物在使用外部事物的内容。

class Body

{

private class Xinzang//Xinzang这个类封装在Baby类中，不对外暴露

{

方法

}

public void show()//而对外提供方法，访问内部类中的功能

{

一些条件满足了就

new Xinzang.方法();

}

注意：类（内部类）可以被私有修饰（当内部类定义在外部类的成员位置上时）

1.内部类访问规则：

示例：

<span style="font-size:18px;">class A
{
int x =1;//外部成员
    class B
  {
 int x =2;//内部成员
    void func()
 {
 int x = 3;//内部局部成员
  //System.out.println("第一个x：" + A.this.x);
     //System.out.println("第二个x：" + this.x);
     //System.out.println("第三个x：" + x);
  System.out.println(x);
 }
  }
}
 class Test6
{
publicstatic void main(String[] args)
{
       A.B b = new A().new B();
       b.func();
//或new A().new B().b.func();直接访问static内部类的静态成员
}
}</span><span style="font-size: 18px; font-family: 'Microsoft YaHei'; background-color: rgb(255, 255, 255);"> </span>

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

内部类定义在局部时，

（1）不可以被成员修饰符修饰

（2）可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

举例略

2，静态内部类

内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。

在外部其他类中，如何访问静态内部类？

示例如下：

class A

{

intx =1;//外部成员