Java初识面向对象

Java初识面向对象

一、初识面向对象

不知道大家在学习Java之前有没有学习过C语言，Java和C语言最大的不同之处就在于Java是面向对象的，而C语言是面向过程的，那么怎样来理解面向对象和面向过程呢？下面我们就举个经典的例子就是将大象装进冰箱如果按照面向过程的思想就是先打开冰箱，再将大象装入进去最后把冰箱给关上是一系列的动作。而从面向对象的角度来看我们关注的是冰箱这个实体对象，由冰箱来完成各种操作。不知道大家对面向对象和面向过程有没有一个初步的了解呢？下面我们就来总结一下面向对象的特点。
面向对象的特点是1.面向对象时是一种常见的思想，符合人们的思考的习惯。2.面向对象的出现将复杂的问题简单化了。3.面向对象的出现让让曾经在过程中的执行者变为了对象中的指挥者。
需要注意的我们一般接触的语言中是面向对象的有C++,java，C#
使用Java语言对现实中事物进行描述的通过类的形式来体现出来，而对象就是类对应的具体的实例。在Java中是通过new来创建的。在类中我们定义了成员分为成员变量和成员的函数，前者值得是类的属性后者指的是类的行为。同时还有一种变量叫做局部变量下面我们来看一下成员变量的和局部变量的区别：
1.成员变量定义在类中在整个类中都有效。而局部变量定义在函数，语句，局部代码块中只在所属的区域才有效。
2.成员变量存在于堆内存的对象中，而局部变量存在于栈内存的方法中。
3.成员变量随着对象的创建而存在随着对象的消失而消失，局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

二、面向对象之封装

封装指的是将隐藏对象的属性和实现细节，仅对外提供公共访问方式，这样做的好处就是将变化进行隔离，便于使用，提供重用性，提高安全性，至于封装的原则就是将不需要的对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
在我的理解中封装可以理解为一个自动取款机我们只能通过外面的触摸屏或者是键盘来操作他而这里的这里的键盘和触摸屏就相当于是封装类中的get和set方法，而要操作的属相就相当于是自动取款机中的钱钱被隐藏起来我们至只能通过公共的方法对其进行操作。
代码体现如下

<span style="font-size:14px;"><span style="font-size:14px;">public class School {

private String  name;
private String  type;
private Integer history;

public School(String name, String type, Integer history) {
super();
this.name = name;
this.type = type;
this.history = history;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}

public Integer getHistory() {
return history;
}

public void setHistory(Integer history) {
this.history = history;
}
}</span></span>

三、面向对象之各种术语

1.构造函数
构造函数就是函数名和类名保持一致,没有具体的返回值，分为有参构造函数和无参的构造函数，上面的School类中定义了一个有参的构造函数，构造函数的作用就是给对象进行初始化操作，多个构造函数可以以重载的形式存在。如果你没有定义构造函数那么程序在创建对象的时候就会调用了其默认的构造函数，默认的构造函数是无参的。特别注意的是如果该类定义了构造函数那么默认的无参的构造函数就不存在了。
那么既然都是类的函数那么构造函数和一般的函数有什么区别呢
(1)构造函数在对象创建时就会被调用，用来对对象进行初始化。而一般函数是对象创建之后需要函数功能时才进行调用。
(2)构造函数是函数创建时被调用一次，而一般函数是对象创建后被调用多次。
2.this关键字
this代表的是本对象的引用,当成员变量和局部变量重名的时候就可以使用this关键字来区分。
特别注意this的另外一个用法是在构造函数中调用另外一个构造函数，调用的时候直接this(参数)注意这句话要放在构造函数的第一句，因为初始化动作要先执行。
3.static关键字
static关键字用于修饰成员这里的成员顾名思义就包括成员变量和成员的函数，被修饰后的成员有以下的特点随着类的加载而加载，优先于对象存在因为随着类的加载被加载，被所有对象所共享，可以被类名直接调用需要注意下面3点
(1)静态方法只能访问静态成员
(2)静态方法中不可以写this，和super关键字
(3)主函数是静态的
当一个成员变量被static修饰后就不是成员变量了称为静态变量或者是类的变量，那么成员变量和静态变量的区别是什么呢？
(1)两个变量的生命周期不一样
成员变量随着对象的创建而存在，随着对象被回收而被释放，静态变量随着类的加载而存在，随着类的消失而消失。
(2)调用的方式不同
成员变量只能被对象调用，静态变量可以被对象调用也可以被类名调用
(3)别名不同
成员也称为实例变量，静态变量称为类变量
(4)数据的存储的位置不同
成员变量数据存储在堆内存对象中，所以也叫对象特有的数据。
静态变量数据存储在方法区，所以也叫对象的共享数据。
静态代码块
静态代码块随着类的加载而加载，只运行一次其作用是对类进行初始化,肯定是在执行构造函数之后了。
构造代码块
构造代码块也是用来给对象进行初始化的，只不过是构造函数具有对象初始化的针对性而构造代码块具有对象初始化的通用性
下面我们通过代码来看下构造函数和构造代码块和静态代码块的执行顺序

<span style="font-size:14px;"><span style="font-size:14px;">public class Person {

static{
System.out.println("我是静态代码块");
}

{
System.out.println("我是构造代码块");
}

public Person(){
System.out.println("我是构造函数");
}

public static void show(){
System.out.println("我是静态方法");
}
}</span></span>

在Person中有一个无参数的构造方法和一个构造代码块一个静态代码块还有一个就是静态方法，首选我们在测试类中通过创建Person对象来观察其执行的顺序

<span style="font-size:14px;"><span style="font-size:14px;">public class HeiMaTest {

public static void main(String[] args) throws Exception {
Person person = new Person();
}
}</span></span>

运行效果截图



可以看出就是静态代码块是随着类的加载被加载的而构造代码块是在创建对象之后执行构造方法之前执行的。
下面我们在测试类中实例化两次Person对象观察效果

<span style="font-size:14px;"><span style="font-size:14px;">public class HeiMaTest {

public static void main(String[] args) throws Exception {
Person person1 = new Person();
Person person2 = new Person();
}
}</span></span>

运行效果截图



因为类被虚拟机加载一次所以静态代码块只被执行了一次。
下面我们在测试类中直接调用Person中的静态方法

<span style="font-size:14px;"><span style="font-size:14px;">public class HeiMaTest {

public static void main(String[] args) throws Exception {
Person.show();
}
}</span></span>

运行效果截图



因为没有创建对象所以的话就没有调用构造代码块。
局部代码块：
局部代码块就是在方法中加一对花括号用来控制局部变量的生命周期。
4.final关键字
final关键字可以修饰类，方法和变量
被final修饰的类不可以被继承
被final修饰的方法不能被覆盖掉。
final修饰的变量是一个常量，只能被赋值一次
对于内部类来只能访问被final修饰的局部变量

四、面向对象之继承

(1)继承的基本概念
想象在现实世界中有多个实体比如说老师，学生，工人他们都有相同的属性姓名，年龄和性别那么在面向对象中我们就把这些公共的属性给抽取出来形成这三个类的父类让他们去继承。
继承的好处就是提高代码的复用性，让类和类之间产生了联系，给第三个特征多态提供了前提。
Java支持多继承，不直接支持多继承，对C++中的多继承进行了改良。不支持多继承的原因就是多个父类具有相同的成员就会产生调用的不确定性。改良之后形成了多重继承A继承了B,B继承了C,C继承了D这种继承方式是被允许的。
继承的时候如果出现子类的成员变量个父类的成员变量一致的话那么必须要采用super关键字来区分了，super指的就是调用父类
当子类中的成员函数和父类中的成员函数有一模一样的情况就会发生子类覆盖父类的情况，这里的一定要注意一模一样，覆盖又称为重写或者是覆写，需要注意的是子类重写父类时子类的权限必须大于父类。
什么时候使用覆盖
当一个类进行子类的扩展时，子类需要保留父类的功能声明，但是还要定义子类中的该功能的特有内容时就需要覆盖操作。
下面我们使用代码来具体了解下上面的知识在代码中的体现
首先是父类Person

<span style="font-size:14px;"><span style="font-size:14px;">public class Person {

public String  name;
public String  sex;
public Integer age;

public Person(){
System.out.println("我是父类的构造函数");
}

public Person(String name,String sex,Integer age){
System.out.println("我是父类的有参数的构造方法");
this.name = name;
this.sex = sex;
this.age  = age;
}

public void show(){
System.out.println("我是父类的show方法");
}
}</span></span>

其次是子类Student

<span style="font-size:14px;"><span style="font-size:14px;">public class Student extends Person {

public String no;

public Student(){
super("张三", "男", 24);
this.no = "020001";
}

public void show(){
super.show();
System.out.println("我是子类中的show方法");
}
}</span></span>

在测试类中进行测试

<span style="font-size:14px;"><span style="font-size:14px;">public class HeiMaTest {

public static void main(String[] args) throws Exception {
Student student = new Student();
student.show();
}
}</span></span>

运行效果截图



如果将Student中的构造函数删除掉那么运行效果截图如下，


子类中所有的构造函数默认都会访问父类中的空参数的构造方法，每个构造函数的第一句都有一句super();如果指定了调用父类中的有参的构造函数纳闷就不会调用这个无参的构造函数

五、面向对象之抽象类

抽象是指从多个事物中将共性和本质的内容提取出来，Java中的抽象类指在Java中可以定义没有方法体的方法，该方法的具体实现由子类实现，该方法称为抽象方法，包含抽象方法的类称为抽象类。
抽象方法的由来
多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明没有功能声明，没有功能主体的方法称为抽象方法。
抽象类的特点
1.抽象类和抽象方法必须用abstract关键字来修饰。
2.抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符 abstract 返回值类型 函数名(参数列表) ;
3.抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：
抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
而且抽象类即使创建了对象，调用抽象方法也没有意义。
4.抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。
考虑下面的几个问题
1.抽象类可以有构造方法吗？
可以有构造函数主要用来给子类对象进行初始化。
2.抽象类可以不定义抽象方法吗？
可以，但是很少见，如果真的出现了目的就是不让该类创建对象，AWT的适配器对象就是这种类，通常这个类的方法有方法体但是没有内容。
3.抽象关键字abstract不能和哪些关键字
private，static，final
4.抽象类和一般类的区别
相同之处就是抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同之处就是
(1)一般类有足够的信息描述事物，抽象类描述事物的信息不足
(2)一般类中不能定义抽象方法，只能定义非抽象方法，而抽象类中既可以定义抽象方法也可以定义非抽象方法。
(3)一般类可以被实例化，但是抽象类不可以被实例化。