面向对象（上）

最新推荐文章于 2024-09-04 10:03:11 发布

大盼

最新推荐文章于 2024-09-04 10:03:11 发布

阅读量585

点赞数

分类专栏： Java 文章标签： java 局部变量设计模式面向对象

本文链接：https://blog.csdn.net/a254830856/article/details/22977615

版权

Java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

知识点汇总

1、面向对象的概念

1.1概念：

面向对象是基于面向过程而言的，面向过程强调的是功能行为，而面向对象是将功能行为封装进对象，强调的是对象。

1.2 举例说明：

比如说我正在使用的计算机，就是一个对象，计算机有显示和播放音乐的功能，而这些功能都被封装进了计算机，计算机就是我们所说的对象。我们只要操作计算机这个对象即可，计算机内部会帮助我们调用相关的功能。

1.3 对象的创建与使用

car c = new car();//c是类类型变量

使用：

类类型变量调用field，可以重新定义field中的值

类类型变量调用函数，执行这个函数

1.4 面向对象的三大特征

封装

继承

多态

2、类的概念

2.1 类是对象的抽象，对象是实实在在存在的实例，而类中的成员描述了对象的状态和功能。类好比是图纸，对象是根据图纸做出来的实体。

2.2 定义类的语法：

[修饰符] class 类名

{

零到多个构造函数的定义；

零到多个field的定义；

零到多个方法的定义；

}

3、类与对象的关系

类是对象的抽象，对象是具备类所描述状态和功能的实实在在存在的个体，类中定义了对象的状态和功能，对象通过类来创建实例

4、成员变量和局部变量

4.1 成员变量

作用范围：成员变量定义在类中，作用于整个类

存储位置：成员变量存在堆内存中

默认初始化：成员变量有默认初始化值

4.2 局部变量

作用范围：局部变量定义在局部范围，例如：函数或者语句中，作用于函数或者语句的范围内

存储位置：局部变量存在栈内存中

默认初始化：局部变量没有默认初始化值，需要自定义初始化；

代码示例：

/**
成员变量和局部变量
*/
class  Demo
{
	public static void main(String[] args) 
	{
		Car c = new Car();
		c.num = 4;
		c.run("红色");
	}
}
class Car
{
	static int num;//num是成员变量
	public static void run(String color)//方法里的color是局部变量
	{
		System.out.println(num+"轮"+color+"车跑了");
	}
}

5、匿名对象

5.1 匿名对象是对象的简化形式，简单的说就是没有类类型变量指向的对象。

示例：具体对象 Car c = new Car(); 匿名对象 new Car()

5.2 使用匿名对象的两种情况：

1. 当对对象方法只进行一次调用时，使用匿名对象；

2. 可以将匿名对象作为实际参数进行传递。

代码示例：

class Bike
{
	int num = 2;
	String color = "red";
	public void go()
	{
		System.out.println("This bike is..."+color+"..."+num);
	}
}
class BikeDemo 
{
	public static void main(String[] args) 
	{
		//Bike b = new Bike();
		//b.go();
		new Bike().go();//匿名对象调用所属类中定义的方法
		fix(new Bike());//匿名对象作为参数进行传递
	}
	public static void fix(Bike b)
	{
		b.num = 3;
		b.color = "black";
		b.go();
	}
}

图示：匿名对象作为参数进行传递，内存示意图

总结：

匿名对象调用变量没有意义，因为匿名对象调用变量操作完毕后，这个对象没有引用指向，就变成了垃圾，会被垃圾回收器回收

匿名对象调用方法有意义，因为方法中有内容，匿名对象调用方法后，将执行方法中的语句

6、封装
6.1 定义：封装是指将对象内部的定义和实现细节进行隐藏，只对外提供公共访问方式。

6.2 封装的原则：

将不需要对外提供的内容都隐藏起来

把field隐藏起来，提供公共方法对其访问

6.3 权限修饰符 private

权限修饰符是封装的一种表现形式

权限修饰符用于修饰类中的成员（成员变量和成员函数）

被私有的成员只在本类中有效，也可以说是只能在本类中被调用

代码示例：

class Bike
{
	private int num = 2;//成员变量num被私有后，只能在本类中被调用
	String color = "red";
	public void go()//该方法被权限最大的public修饰，是对外提供的公共访问方式，外部类中的对象可以通过此方法来访问这个类
	{
		System.out.println("This bike is..."+color+"..."+num);
	}
}
class BikeDemo 
{
	public static void main(String[] args) 
	{
		//Bike b = new Bike();
		//b.go();
		new Bike().go();
		fix(new Bike());
	}
	public static void fix(Bike b)
	{
		b.num = 3;//因为num被私有了，所以这句会报错
		b.color = "black";
		b.go();
	}
}

7、构造函数

7.1 构造函数的特点：

1.函数名和类名相同

2.不用定义返回值类型

3.不可以写return语句

4.构造函数的权限小于或者等于类的权限

7.2 构造函数的作用：

构造函数是用于给对象初始化的，对象一建立就会调用与之对应的构造函数；

如果程序员没有定义构造函数，JAVA默认情况下，会隐式的定义一个空参数的构造函数，定义后，空参数构造函数消失；

多个构造函数是以重载的形式出现的。

7.3 什么情况下需要定义构造函数？

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

代码示例：

class Person
{
	private String name;
	private int age;
	//Person(){}默认的空参数构造函数，如果定义了构造函数，那么这个构造函数就消失了
	public Person()//构造函数,无返回值类型，和类名相同（包括大小写）
	{
		String name ="zhangsan";
		int age = 24;
		System.out.println("name:"+name+"...age:"+age);
	}
}
class  PersonDemo
{
	public static void main(String[] args) 
	{
		new Person();
	}
}

8、构造函数和一般函数的区别（非常重要）

8.1 写法不同

一般函数必须有返回值类型，当没有返回值时，返回值类型为void，函数名自定义，当执行语句中有返回值时，必须使用return语句返回该值，没有返回值时，return语句可以省略；

构造函数：不用定义返回值类型，函数名必须和类名相同，不可以写return语句

8.2 运行状态不同

一般函数：当对象调用这个函数时函数才运行，给对象添加对象具备的功能

构造函数：对象一建立就运行，用于给对象初始化

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

一般函数可以被对象调用多次。

代码示例：

class Person
{
	String name;
	int age;
	public Person()//构造函数
	{
		String name = "zhangsan";
		age = 77;
		System.out.println(name+"..."+age);
	}
}
class  Funtion
{
	public static void main(String[] args) 
	{
		Person p = new Person();//对象一建立就执行构造函数
		fix("lisi",23);
	}
	public static void fix(String name,int age)//一般函数，调用时，此函数运行，否则不执行
	{
		System.out.println(name+"..."+age);
	}
}

9、构造代码块

9.1 定义格式：{}

9.2 构造代码块作用：用于给对象进行初始化，对象一建立就运行，而且优先于构造函数执行

10、构造函数和构造代码块的区别

10.1 构造函数是给对应的对象进行初始化的，构造代码块是给所有对象统一进行初始化

代码示例：

class Person
{
	{
		System.out.println("这是构造代码块");
	}
	private String name;
	Person(String name)
	{
		System.out.println("这是"+name+"的构造函数");
	}
}

class CodeBlock 
{
	public static void main(String[] args) 
	{
		Person p1 = new Person("zhangsan");
		Person p2 = new Person("lisi");
	}
}

运行结果：

11、this关键字

11.1 this代表它所在函数的所属对象的引用，简而言之，就是代表本类对象的引用

11.2 this作用：

区分同名变量

用于构造函数间的调用

11.3 使用注意事项：this语句只能定义在构造函数的第一行。因为初始化要先执行。

代码示例：

/**
this关键字的应用
需求：
初始化一个对象
修改对象中的参数，
输出修改后对象的信息
*/
class Person
{
	private String name ="lisi";
	private int age = 23;
	Person()
	{
		this.name = name;
		this.age = age;
		System.out.println("name:"+name+"...age"+age);
	}
	void setName(String name)
	{
		this.name = name;//p2调用setName方法，this就等同于this,这句话可以写成p2.name = name;
			System.out.println("name:"+name);
	}
	void setAge(int age)
	{
		this.age = age;
		System.out.println("age:"+age);
	}
	void info(String name,int age)
	{
		System.out.println("name:"+name+"...age:"+age);
	}
	public String toString()
	{
		return ("name:"+name+"...age:"+age);
	}

}
class  ThisKeyWord1
{
	public static void main(String[] args) 
	{
		//p1和p2的默认初始化值相同都是：lisi,23
		Person p1 = new Person();
		Person p2 = new Person();
		//p2经过以下代码的修改后
		p2.setName("zhangsan");
		p2.setAge(23);
		//p2输出一个全新的值
		System.out.println(p2.toString());
	}
}

12、static关键字

12.1 static是一个修饰符，用于修饰成员（成员变量和成员函数）

静态修饰的内容被对象共享

当成员被静态修饰后，除了可以被对象调用外，还可以直接被类名调用（多了一种调用方式）

类名.静态成员

12.2 static特点：

1，随着类的加载而加载，随着类的消失而消失，生命周期最长

2，优先于对象存在

3，被所有对象共享

4，可以直接被类名调用

12.3 静态使用注意事项：

1，静态方法只能访问静态成员

非静态方法既可以访问静态成员也可以访问非静态成员

2，静态方法中不可以定义this和super关键字

因为静态优先于对象存在，所以静态方法中不能出现this

3，主函数是静态的

12.4 静态的利和弊

利：

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

2.可以被类名直接调用

弊：

1.生命周期过程长

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

12.5 什么时候使用静态？

要从两方面入手：（因为静态修饰的内容有成员变量和成员函数）

1，什么时候定义静态变量（类变量）？

当对象中出现共享数据时，该数据被静态所修饰

对象中的特有数据要定义成非静态存在于堆内存中

2，什么时候定义静态函数？

当功能内部没有访问到非静态数据时（对象的特有数据），那么该功能可以定义成静态的

代码示例：

/**
静态应用
当对象中出现共享数据时，该数据被静态所修饰
对象中的特有数据要定义成非静态存在于堆内存中
*/
class Person
{
	private String name;
	private int age;
	private static String country = "cn";//共享数据
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public void setName(String name)
	{
		this.name = name;
		Person.show();
	}
	public static void show()//特有数据
	{
		System.out.println("good name");
	}
}
class StaticDemo
{
	public static void main(String[] args) 
	{
		Person p = new Person("ok",50);
		p.setName("lisi");
	}
}

13、main函数

主函数的定义：主函数是一个特殊的函数，他是程序的入口，可以被JVM识别

public：代表着函数访问权限是最大的

static：代表主函数随着类的加载就已经存在了

void：主函数没有具体的返回值

main：不是关键字，但是是一个特殊的单词，可以被JVM识别

（String[] args）：函数的参数，参数类型是一个数组，该数组中的元素是字符串。

14、实例变量和类变量的区别

14.1 存放位置不同

类变量随着类的加载而存在于方法区中；

实例变量随着对象的建立而存在于堆内存中

14.2 生命周期不同

类变量生命周期最长，随着类的消失而消失

实例变量生命周期随着对象的消失而消失。

15、静态代码块

15.1 格式：

static

{

静态代码块中的执行语句；

}

15.2 静态代码块的特点：

随着类的加载而执行，只执行一次，并且优先于主函数，用于给类初始化

类被调用的时候静态代码块才被执行。

16、帮助文档的制作（javadoc）

16.1 语句命令格式：

javadoc -d myhelp -author -version ArrayTool.java

-d:目录

myhelp:建立帮助文档所存储的文件夹名

-author -version:作者和版本号，两个特殊的地方，可以不写

ArrayTool.java:源文件

16.2 注意事项：

做帮助文档时，要将类暴露出去，否则视为封装，Javadoc将获取不到类中的方法。使用修饰符public暴露类；

凡是public，protect修饰符修饰的功能都能被javadoc工具抽取

否则即使加了文档注释也不会在帮助文档中看到此方法。

17、对象的初始化过程（一定要能自己画出来）

Person p = new Person();执行此句代码，所做的事

1.因为new一个Person对象，用到了Person.class，所以虚拟机会先找到Person.class文件并加载到内存中；

2.执行该类中的static代码块，给Person.class类进行初始化

3.在堆内存中开辟空间，分配内存地址值；

4.在堆内存中建立对象的特有属性，并进行默认初始化；

5.对属性进行显示初始化；

6.对对象进行构造代码块初始化；

7.对对象进行对应的构造函数初始化；

8.将内存地址赋给栈内存中的p变量。

18、对象调用成员过程

代码示例：

/**
对象中成员的调用过程
*/
class Student
{
	private Student(){};
	private String name;
	private int age;
	private static String school = "middle school";
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public String toString()//输出对象的自我描述信息
	{
		return "name:"+name+"...age:"+age;
	}
}
class StudentDemo
{
	public static void main(String[] args) 
	{
		Student s = new Student("zhangsan",11);
		s.setName("lisi");
		System.out.println(s.toString());
	}
}

图例：

19、单例设计模式

19.1 概念：解决一个类在内存中只存在一个对象的问题

19.2 保证对象唯一的思路：

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

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

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

19.3 代码实现步骤

1.将构造函数私有化

2.在类中创建一个本类对象

3.提供一个方法可以获取到该对象

代码示例：

饿汉式：

class Single
{


	private  Single(){};

	private static Single s = new Single();

	public static  Single getInstance()
	{
		return s;
	}
}
class SingleDemo 
{
	public static void main(String[] args) 
	{
		Single s1 = Single.getInstance();
		Single s2 = 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;
	}
}
class SingleDemo 
{
	public static void main(String[] args) 
	{
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
	}
}

图例：

饿汉式：