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

2、数据类型：包含基本数据类型和引用数据类型
3、属性名、方法名：同变量的定义规则；
4、 返回值类型：
a) 没有返回值使用 void；
b) 有返回值可以是基本数据类型或者引用数据类型
5、参数列表：包含参数的类型，个数，顺序。
6、 程序代码：顺序结构、分支语句、循环语句；
7、return：只有当方法有返回值的时候才需要，值或表达式结果的类型必须和返回值类型相同或者它的小类型。

//没有返回值没有传参
void eat(){
System.out.println("eat");
}
//没有返回值有传参
void eat(String str,int a){
System.out.println("eat");
}
//有返回值有传参
int eat(String str,int a){
System.out.println("eat");
return 100;//换成(byte)100;
}

访问类中的属性和方法：如果需要去访问类中的属性和方法，则需要先创建该类的对象。

调用属性：对象名.属性名;
调用方法：对象名.方法名(参数列表);

public class Person {
String name; // 定义属性，人的姓名
int age; // 定义属性，人的年龄
/\*\*
\* 定义方法，显示人的姓名和年龄
\*/
public void show() {
// +和字符串一起使用的时候表示连接而非加分运算
System.out.println("姓名:" + name + ",年龄:" + age);
}
public static void main(String[] args) {
Person person = new Person(); // 创建人的对象，即某一个成员
person.name = "jack"; // 初始化人的姓名，通过赋值=将jack赋值给该对象的姓名属性
person.age = 34; // 初始化人的年龄，通过赋值=将34赋值给该对象的年龄属性
person.show(); // 调用show()方法
} }

PS:通过对象调用属性和方法，可以在同一个类的 main 方法中调用，也可以在不同的类中进行调用。

3.6 内存的划分

内存的操作，为属性赋值：

PS：栈空间保存的是基本数据类型和字符串，包括局部变量的引用，堆空间保存的动态产生的数据，比如 new 创建出来的对象，也就是引用数据类型。上面两个 Person 实例在堆空间开辟了两块内存，那么相互之间进行调用的时候就不会受到影响，只要使用了 new 关键字，必会在堆空间开辟内存。

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();
} 
} 
}