Java基础教程【第六章：面向对象】_构造函数的主要作用是完成对类的对象的初始化工作

本文链接：https://blog.csdn.net/2401_84023604/article/details/137736608

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

4. 构造函数，方法的重载

4.1 定义

要使用面向对象，首先必须构造对象，并指定它们的初始状态，然后通过对象调用方法。在 java 的语言设计中，使用构造函数(constructor)来构造新的实例，一个构造函数是新的方法，它的作用就是构造对象并进行初始化。

4.2 特点

（1）构造函数的方法名与类名相同。
（2）构造函数没有返回类型。
（3）构造函数的主要作用是完成对类对象的初始化工作。
（4）构造函数不能由编程人员显式地直接调用。
（5）在创建一个类的新对象的同时，系统会自动调用该类的构造函数为新对象初始化。

public class Person {
String name;
int age;
//要使用Person的方法，必须先创建Person类的对象，在创建对象的同时对name，age属性进行了初始化
public Person(String name, int age) {
super();
this.name = name;
this.age = age; } }

4.3 作用

（1）对象初始化
（2）引入更多的灵活度（变量赋值或更复杂的操作）
（3）Java 中可以不定义构造函数
Java 中可以不定义构造函数，此时系统会自动为该系统生成一个默认的构造函数。这个构造函数的名字与类名相同，它没有任何形式参数，也不完成任何操作。为了避免失去控制，一般将构造函数的声明与创建分开处理。

4.4 构造函数重载

一个类可以有多个构造函数，如果一个类没有定义一个构造函数，Java 编译器将为这个类自动提供缺省构造函数(即无参的构造函数) ，缺省构造函数将成员变量的值初始化为缺省值，一旦创建了自己的构造函数， Java 编译器将不再自动提供无参的构造函数。
重载构造函数提供了一组创建对象的方式，可以根据需要决定是否带初始参数。根据参数列表决定调用的是哪个重载的构造函数。
构造函数重载：一个类中可以有多个构造函数，它们具有不同的参数列表(参数的类型、个数、顺序)

public class Person {
	String name;
	int age;
	public Person() {
	System.out.println("无参的构造函数");
	}
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("带两个参数的构造函数1");
	}
	public Person(int age, String name) {
		this.name = name;
		this.age = age;
		System.out.println("带两个参数的构造函数2");
	}
	public Person(String name) {
		this.name = name;
		System.out.println("参数为name的构造函数");
	}
	public Person(int age) {
		this.age = age;
		System.out.println("参数为age的构造函数");
	} 
}

this 关键字：与对象关联，表示当前对象（实例），即 new 出的是哪个对象，代表的就是哪个对象。this 关键字的作用：可以调用调用类中的构造方法，普通方法，成员变量。this 调用构造方法只能是在构造方法中使用，必须是第一行。

public class Person {
String name;
int age;
public Person() {
this("jack");//如果使用this调用构造方法，必须在第一行，只能在构造方法种调用构造方法。
System.out.println("无参的构造函数");
this.show();
}
public Person(String name) {
this(20);
System.out.println("参数为name的构造函数");
}
public Person(int age) {
System.out.println("参数为age的构造函数");
}
public void show(){
//this(); //不可调用。
System.out.println("show");
}
public static void main(String[] args) {
new Person();
}
}

方法重载：方法重载是 java 中实现面向对象多态性机制的一种方式。
同一个类中多个方法有相同的名字，不同的参数列表（参数的个数，类型，顺序），和返回值类型无关，这种情况称为方法重载。
当重载方法被调用时，Java 编译器根据参数的类型、数量、顺序来确定实际调用哪个重载方法的版本。方法重载不考虑方法的返回类型。

5. 封装

a)封装是对象的一种隐藏技术，其目的是将对象中的属性和方法组织起来。同时隐藏不想暴露的属性和方法及实现细节。
b)用户或其它对象不能看到也无法修改其实现。只能通过接口去调用对象的方法，达到互相通信的目的。
c)封闭的目的在于将设计者与使用者分开。使用者不必知道实现的细节，只需用设计者提供的方法来访问该对象。

public class DrawImage {
private int weight;
private int height;
public void setHeight(int height) {
if (height > 100)
System.out.println("高度不能高于100");
else
this.height = height; }
public int getHeight() {
return height; }
public void setWeight(int weight) {
if (weight > 200)
System.out.println("宽度不能大于200");
else
this.weight = weight; }
public int getWeight() {
return weight; }
public void draw() {
drawLine();
drawPoint();
System.out.println("你画了一幅画");
}
private void drawPoint() {
System.out.println("画了一个点");
}
private void drawLine() {
System.out.println("画了一条线");
} }

6. 继承，抽象，方法重写

继承是面向对象编程技术的一块基石，它允许创建分等级层次的类。运用继承，可以创建一个通用类定义一系列一般特性。该类可以被更具体的类继承。
（1）被继承的类称为父类或者超类或者基类
（2）继承父类的类称为子类或者派生类
（3）执行继承时，子类将获得父类的所有成员（包括 private 的成员,私有的不能直接访问），并具有自身特有的属性。

super 关键字：
super 是一个引用，专门用来在子类中访问父类中的构造函数、方法和实例变量。
1.使用 super 在子类的构造函数中调用父类的构造函数，语法：
super()或者 super(参数列表)
super()必须是在子类构造函数中的第一个执行语句。

2.在子类的方法中调用父类中的方法，语法：
super.方法名(参数列表)

3.在子类的方法中调用父类中的实例变量，语法：
super.实例变量名

继承总结：
1、子类继承父类，继承了父类的所有属性和方法(包含私有的)，私有的不能直接访问；
2、一个类如果没有使用 extends，那么它将继承 Object 类，Object 类是所有类的父类，始祖类；
3、一个类可以继承多个类，但 java 中规定一个类只能直接继承一个类；可以间接继承；
4、子类具有扩展的功能，扩展子类特有的属性和方法；
5、继承大大提供了代码的重复利用性

方法重写（覆盖）override：是 java 实现多态机制的另外一种形式。
在不同类中，如果子类中的一个方法与父类中的方法有相同的返回类型、相同的方法名并具有相同数量和类型的参数列表，这种情况称为方法覆盖。
当一个覆盖方法通过父类引用被调用，Java 根据当前被引用对象的实际类型来决定执行哪个版本的方法。
可以通过 super 关键字调用直属父类中被覆盖的方法版本。

//方法重写示例：
public class Father {
public String say(){
return "我是父类"; } }
public class Son extends Father {
@Override
public String say() {
// super.say();//当创建的是子类对象的时候，如果需要调用父类的方法可以使用super关键字
return "我是儿子类"; } }
public class Daughter extends Father{
@Override
public String say() {
return "我是女儿类"; } }
public class Test {
public static void main(String[] args) {
Father f = new Father();
f.say();// 创建的是父类对象，调用的是是父类方法
Father s = new Son();
s.say();// 创建的是儿子类对象，调用的是儿子类方法
Father dau = new Daughter();
dau.say();// 创建的是女儿类对象，调用的是女儿类的方法
} 
}

抽象类：
定义：一种类型，只提供部分方法的具体实现。
语法：abstract class 类名{
….
}

一般情况下，抽象类既包含具体方法，又包含抽象方法。
具体方法：既有方法的声明，又有方法的实现（即有方法体)。
抽象方法：只有方法的声明，而没有方法的实现（即没有方法体)。
语法：abstract 返回类型方法名(参数列表)

//抽象类的示例：
public abstract class Father {
String name;
int age;
public Father() {
}
public Father(String name, int age) {
this.name = name;
this.age = age; }
public abstract void say();// 抽象方法，没有方法体
public void see() {
System.out.println("see");
} }
public class Son extends Father {
public Son() {
}
public Son(String name, int age) {
super(name, age);
}
// 必须要重写父类的所有抽象方法，包含间接父类
@Override
public void say() {
System.out.println("我必须要重写父类的所有抽象方法");
} }
public class Test {
public static void main(String[] args) {
Father f = new Son();//抽象类不能被实例化，必须通过子类进行实例化
f.say();
} 
}

总结：
抽象类不能被实例化。
抽象类就是用来继承的。
子类必须为抽象类中的所有抽象方法提供具体实现，否则，子类也将是一个抽象类。
抽象类中可以声明实例变量，这些实例变量就是为了提供给子类继承的。
抽象类可以有一个或多个构造函数，它是提供给子类进行调用的。
特别地，抽象类中的所有方法都可以是具体方法。

7. 多态

多态和动态绑定：
声明类型：对象变量被声明时的类型
实际类型：对象变量实际指向的对象类型
一个对象变量可以指向多种实际类型的现象称为“多态”
在运行时自动选择正确的方法进行调用的现象称为“动态绑定”
Java 根据对象的实际类型来进行方法调用
==编译时多态：编译时动态重载.（方法重载） ==
运行时多态：指一个对象可以具有多个类型。（方法重写）

//多态示例 1：
public class Test {
public void add(int a, int b) {
}
public void add(short a, short b) {
} }
//多态示例 2：
public abstract class Father {
public abstract void say();
}
public class Son extends Father {
@Override
public void say() {
System.out.println("Son is say");
}
public void play() {
System.out.println("Son is play");
} }
public class Daughter extends Father {
@Override
public void say() {
System.out.println("Daughter is say");
}
public void sing() {
System.out.println("Daughter is sing");
} }
public class Test {
public static void main(String[] args) {
Father f = new Son();
f.say();
// instanceof判断一个对象是否属于一个类，必须有继承关系
if (f instanceof Son) {
((Son) f).play();//
}f = new Daughter();
f.say();
if (f instanceof Daughter) {
((Daughter) f).sing();
} 
} 
}

总结：运行时多态的三大前提条件
1.要有继承
2.要有方法的重写
3.父类引用指向子类对象（对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接）