java面向对象编程

最新推荐文章于 2021-03-16 19:28:20 发布

thomaszhengzhao

最新推荐文章于 2021-03-16 19:28:20 发布

阅读量450

点赞数

分类专栏： java 基础文章标签： java 面向对象编程继承封装

本文链接：https://blog.csdn.net/u012942674/article/details/46352899

版权

java 基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Java语言是纯粹的面向对象的程序设计语言。其最小程序单位是类，类在java中处于核心地位。类定义了对象的外形和属性，它是一种逻辑结构，整个java语言基于类而构建。

过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。

特点：1：将复杂的事情简单化。

2：面向对象将以前的过程中的执行者，变成了指挥者。

3：面向对象这种思想符合现在人们思考习惯。

在类中定义其实都称之为成员。成员有两种：

1：成员变量：其实对应的就是事物的属性。

2：成员函数：其实对应的就是事物的行为。

类通过class关键词声明。简化后的类定义的一般形式：

class classname{

type instance-variable1;//成员变量

type instance-variable2;

type instance-variable3;

//成员函数

type methodname1(parameter-list){

//方法体

}

type methodname2(parameter-list){

//方法体

}

访问修饰符：

1）private：类访问权限:本类内部可以访问,不能继承到子类;

2）default：什么都不写,包访问权限:本类内部可以访问，同包其他类也可以访问,同包可继承;

3）protected：子类访问权限:本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问,能继承到子类;

4）public：公共访问权限:任何地方都可以访问,能继承到子类;

被private修饰的成员称为私有成员，其他类不能直接创建对象访问，所以只有通过本类对外提供具体的访问方式来完成对私有的访问，可以通过对外提供函数的形式对其进行访问。好处是：可以在函数中加入逻辑判断等操作，对数据进行判断等操作。

总结：开发时，记住，属性是用于存储数据的，直接被访问，容易出现安全隐患，所以，类中的属性通常被私有化，并对外提供公共的访问方法。

这个方法一般有两个，规范写法：对于属性 xxx，可以使用setXXX(),getXXX()对其进行操作。

构造函数：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。所有对象创建时，都需要初始化才可以使用。

特点：

1：该函数的名称和所在类的名称相同。

2：不需要定义返回值类型。

3：该函数没有具体的返回值。

注意事项：一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。

一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。

class Person
{
	private String name = "hah";
	private int age;
	private static  String country = "cn";
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	{
		System.out.println(name+".."+age);
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public void speak()
	{
		System.out.println(this.name+"..."+this.age);
	}
	public static void method()
	{
		System.out.println("method run");
	}

}

class  PersonDemo
{
	public static void main(String[] args) 
	{
		Person p = new Person("thomas",20);
                p.speak();
		p.setName("tom");
		method();
	}
}

注意：

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

面向对象的三点特征：封装、继承、多态。

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

好处：将变化隔离；便于使用；提高重用性；安全性。

this:代表对象。就是所在函数所属对象的引用。

this到底代表什么呢？哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用。

开发时，什么时候使用this呢？在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。

this 还可以用于构造函数间的调用。

调用格式：this(实际参数)；

this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；

this对象后面跟上 () 调用的是本类中的对应参数的构造函数。

注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。

继承：使用extends关键词将类集成到另一个类中。

好处：

1：提高了代码的复用性。

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

父类的由来：其实是由多个类不断向上抽取共性内容而来的。

java中对于继承，java只支持单继承。java虽然不直接支持多继承，但是保留了这种多继承机制，进行改良。

单继承：一个类只能有一个父类。

多继承：一个类可以有多个父类。

子父类出现后，类中的成员都有了哪些特点：

1：成员变量。

当子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。

如果想要调用父类中的属性值，需要使用一个关键字：super

This：代表是本类类型的对象引用。

Super：代表是子类所属的父类中的内存空间引用。

注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。

2：成员函数。

当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况，是函数的另一个特性：覆盖

3：构造函数。

发现子类构造函数运行时，先运行了父类的构造函数。为什么呢?

原因：子类的所有构造函数中的第一行，其实都有一条隐身的语句super();

super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。

为什么子类对象初始化时，都需要调用父类中的函数？

因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。

class Father
{
	int num ;
	Father()
	{
		num= 10;
		System.out.println("Father ");
	}
	Father(int  x)
	{
		System.out.println("Father:"+x);
	}
	
}
class Child extends Father
{
	Child()
	{
		super();  
		System.out.println("Child run");
	}
	Child(int x)
	{
		this();
		System.out.println("Child:"+x);
	}
}

class  ExtendsTest
{
	public static void main(String[] args) 
	{
		Child z = new Child(0);
		System.out.println(z.num);
	}
}