本文详细介绍了Java面向对象的高级特性，包括静态成员与方法、单例设计模式、继承与多态等概念，并探讨了它们的使用场景及注意事项。
面向对象：
一．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;//外部成员
static class B
{
int x =2;//内部成员
static void func()//当内部类中定义了静态方法，那么该内部类也必//须是static的。
{
int x = 3;//内部局部成员
//System.out.println("第三个x：" + x);
}
}
}
class Test6
{
publicstatic void main(String[] args)
{
A().B() .func();//直接访问static内部类的静态成员
}
}
3.匿名内部类
要点：（1）内部类的简写格式
（2） 定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
（3） 匿名内部类的格式：new 父类或接口（）{定义子类的内容}
注：（定义子类的内容中包含：覆盖父类的内容+可有子类特有的内容）
（4） 匿名内部类就是一个匿名子类对象
（5） 匿名内部类中的方法最好不要超过三个
示例：
abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x=3;
/*class Innerextends AbsDemo
{
void show()//复写父类方法
{
System.out.println(“method:”+x);
}
}*/
public void function()
{
//newInner.show();//创建内部类对象并调用其show方法
new AbsDemo()
{
void show()//复写父类方法
{
System.out.println(“method:”+x);
}
}(//是AbsDemo的匿名子类对象).show();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
new Outer().function();
}
}
扫一扫
525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
