面向对象（中）

最新推荐文章于 2024-09-16 16:08:34 发布

原创最新推荐文章于 2024-09-16 16:08:34 发布 · 385 阅读

CC 4.0 BY-SA版权

本文深入探讨了ASP.NET、Android、IO开发及.NET培训的基础知识，包括main函数重载、类构造函数、静态代码块、对象创建过程、单例设计模式、继承、变量变化、函数重写、构造函数、final关键字、抽象类、接口初步概念等核心内容。通过实例讲解，帮助开发者理解和应用这些关键概念。

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

1、关于main函数的小问题

class MainDemo 
{
	public static void main(String[] args)
	{
		
	}
	public static void main(int x)
	{
		
	}
}

要问的是这样写，编译能通过么，当然是能的，因为，main虽然特殊，可说到底还是函数，函数就有重载的特性，这个当然是可以编译通过的

2、关于一个类中默认的构造函数

一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。如果类被public修饰，那么默认的构造函数也带public修饰符。如果类没有被public修饰，那么默认的构造函数，也没有public修饰。默认构造构造函数的权限是随着的类的变化而变化的。

3、关于静态代码块

静态代码块。
格式：
static
{
静态代码块中的执行语句。
}
特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。

4、new一个对象时，内存中发生了什么

//比如说有一个Person类
Person p = new Person("zhangsan",20);

该句话都做了什么事情？
(1)因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
(2)执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
(3)在堆内存中开辟空间，分配内存地址。
(4)在堆内存中建立对象的特有属性。并进行默认初始化。
(5)对属性进行显示初始化。
(6)对对象进行构造代码块初始化。
(7)对对象进行对应的构造函数初始化。
(8)将内存地址付给栈内存中的p变量。

5、单例设计模式

设计模式：解决某一类问题最行之有效的方法。java中23种设计模式：

单例设计模式：解决一个类在内存只存在一个对象。

思路：
想要保证对象唯一。
(1)为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
(2)还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
(3)为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三部怎么用代码体现呢？
(1)将构造函数私有化。
(2)在类中创建一个本类对象。
(3)提供一个方法可以获取到该对象。
对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

//这是一个单例类，这个方式成为饿汉式并且是开发中常用的
class Single
{
	//构造函数设为私有，这样在本类外就不能new本类对象了
	private Single(){}
  //用静态的函数调用到这个s，因此s也要为静态的
	private static Single s = new Single();//Single类一进内存，就已经创建好了对象
  
  //该方法提供本类对象，但是要别人能够调用的话，就得设为静态
	public static  Single getInstance()
	{
		return s;//返回一个本类对象
	}
}

还有一种 懒汉式
特点是：对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)//这是一个锁
			{				
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}

6、关于继承的基本认识

继承：
(1)提高了代码的复用性。
(2)让类与类之间产生了关系。有了这个关系，才有了多态的特性。
但是要注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。
而且要是知道的是：java只支持单继承不支持多继承
原因是：因为多继承容易带来安全隐患:当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承。也就是一个继承体系，如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。

那么在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
简单一句话：查阅父类功能，创建子类对象使用功能。

7、在继承中变量的变化

如果子类中出现非私有的同名成员变量时，
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。

8、继承中的函数

当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写(覆盖)

//这段代码没啥难度，主要看子类上怎么调父类方法的
class Tel
{
	void show()
	{
		System.out.println("number");
	}
	
}

class NewTel extends Tel
{
	void show()
	{
		//System.out.println("number");
		super.show();//直接调用父类中写好的方法  
		System.out.println("name");
		System.out.println("pic");
	}
}

要注意的是：
(1)子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。还有，要是父类中的函数用private修饰，子类中的同名函数就不是覆盖了
(2)静态只能覆盖静态。

9、继承中的构造函数

其实也就是子类的实例化过程
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super(); 当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

10、关于final一些小知识点

final : 最终。作为一个修饰符，
(1)可以修饰类，函数，变量。
(2)被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
(3)被final修饰的方法不可以被复写。
(4)被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。单词间通过 _ 连接。
(5)内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。

11、抽象类

想想看，抽象类有啥好处？
我自己的理解：如果我要继承一个抽象类，那么我就必须覆写该类中所有的抽象方法，否则的话，自己这个类也就会变成抽象类了，所以，想想看，当我需要我不清楚本类的对象具体该干些甚么，但是需要本类的子类一定要做这件事的话，那就定义抽象类吧。当然要记住，抽象类中也是可以有非抽象方法的，还有就是，抽象类中也可以不定义抽象方法

这个是课上讲的练习，我觉得很有代表性，还是记录下来吧
需求：
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
员工类：name id pay
经理类：继承了员工，并有自己特有的bonus。

/*
 注意，在最终的代码出现之前，是有个思考的过程的，首先写的是Employee 和Manager两个类，然后用后者去继承前者
 但是发现，work这个方法，两者的实现方式显然是不一样的，所以，继续想，一个那么多的员工，具体的工作方式是什么
 是无法具体说出来的，因此这个员工的类是要抽象的，也就像下面的代码那样
*/
abstract 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");
	}
}

12、接口的初步概念

接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口。
接口定义时，格式特点：
(1)接口中常见定义：常量，抽象方法。
(2)接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。
接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。还有就是：接口之间也是可以继承的，而且一个接口可以继承多个接口

//举个小例子
interface Inter
{
	public static final int NUM = 3;
	public abstract void show();
}

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