构造方法
(构造器/构造函数/构造方法)
1. 定义：
. 构造方法的名字和类的名字相同
. 没有返回类型，有返回类型的构造器就变成了普通方法。
2. 调用时刻：
在创建对象的时候调用；
注意：是先创建对象，然后初始化对象中的属性值,最后在调用构造器
3. 作用：
可以让我们在创建对象的时候做一些对象中数据的初始化工作.(因为在new的后面就是写的构造器)
new Student();
new Student("tom",age);
4. 构造方法的调用：
构造方法只能通过以下方式被调用：
. 当前类的其他构造方法通过this语句调用它；public A(){this(5)}----public A(int a){ this();}这里的this必须在最代码的最上面
. 当前类的子类的构造方法通过super语句调用它；
public A(int a){}-----public B(){
super(5)；
}
. 在程序中通过new语句调用它；
public A(int 5){
}
public void c(){
A a=new A(5);
}
默认的构造方法
构造方法可分为两种：
1) 隐含的默认构造方法(无参构造器)；public A(){} 系统自动生成
2) 程序显示定义的构造方法；public A(int a,int b){} 个人定义，自己定义的时候JVM不会默认生成无参构造器，必须自己再次定义
在Java语言中，每个类至少有一个构造方法。为了保证这一点，如果用户定义类中没有提供任何构造方法，那么在运行的时候JVM将自动提供一个隐含的默认构造方法。该构造方法没有参数，用public修饰，而且方法体为空，格式如下：
public ClassName(){} //隐含的默认构造方法
在程序中也可以显示地定义默认构造方法。
如果类中显式定义了一个或多个构造方法，那么Java语言便不再分配隐含的默认构造方法。举例：
public class Sample{
public Sample(int a) {
System.out.println("My Constructor");
}
}
创建Sample类对象的语句:
Sample s1 = new Sample(); //编译出错需要创建public Sample(){} 无参构造方法
Sample s2 = new Sample(1); //合法的
创建和初始化对象
按照前面讲述的定义类的形式、定义方法的形式，构建好类了之后，程序要真实的运行，还是得通过对象的交互来完成。
创建好了类，只是创建了构建对象的模板。接下来，我们可以通过new操作符，快速地构建出对象。使用new有以下作用大致有以下几步：
Student stu=new Student();
1.为对象分配内存空间，将对象的实例变量自动初始化默认值；
2.如实例变量显示初始化，将初始化值赋给实例变量(把默认值覆盖掉)；
3.调用构造方法；
4.返回对象的地址值；
构造方法重载
当通过new语句创建一个对象时，在不同的条件下，对象可能会有不同的初始化行为。
可通过重载构造方法来表达对象的多种初始化行为。在一个类的多个构造方法中，可能会出现一些重复操作。
为了 提高代码的可重用性，Java语言允许在一个构造方法中，用this语句来调用另一个构造方法。
使用this语句来调用其他构造方法时，必须遵守以下语法规则:
1.假如在一个构造方法中使用了this语句，那么它必须作为构造方法的第一条要执行的语句(不考虑注释语句)。
2.只能在一个构造方法中用this语句来调用类的其他构造方法，而不能在实例方法中用this语句来调用类的其他构造方法；
3.只能用this语句来调用其他构造方法，而不能通过方法名来直接调用构造方法。
数据隐藏
这里所说的数据主要指的是类中的属性
如何对属性进行隐藏呢？
在前面封装的属性前面用private修饰，表示该属性不能被其它类访问和修改，它只能被本类访问和修改，范围限制在本类内。
java中封装有两个方面：
属性的封装：
方法的封装
封装
1.对属性的封装
首先属性可以被一下修饰符修饰:
public protected "default" private(这四种修饰符可以修饰成员变量,也可以修饰方法)
public String name;
protected String name;
private String name;
//这样就是default
String name;
//这样写是错的
default String name;
private修饰的只能在本类中访问，别的方法想要访问，需要通过方法来调用对属性的访问；
注: 四种修饰符的作用之后会讨论
对属性的封装:在属性(实例变量)前加private, 然后通过统一的方法访问以及修改这些属性值；
使用get/set方法来访问类中被private修饰的属性。
这样做的目的就是隐藏数据信息，保证数据的安全。
2.方法的封装:(指的是用方法来封装代码)
站在使用的者的角度去考虑，用户只关心方法的使用,不管里面到底怎么实现的细节.
从编程的角度去看的话:为了代码的重用。
方法重载(overload)
有时侯，类的同一种功能有多种实现方式，换句话说，有很多相同名称的方法，参数不同。这给用户对这种功能的调用使用提供了很大的灵活性。
例如:Test类中要求有俩个方法:
public void print(int i){
System.out.println("i = "+i);
}
public void print(String s){
System.out.println("s = "+s);
}
对于类的方法(包括从父类中继承的方法), 如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。这种现象叫重载。
重载必须满足以下条件：
1) 方法名称相同。
2) 参数列表不同(参数类型、个数和顺序)。
注意: 返回类型可以不相同。大量的构造方法就是方法重载
在一个类中不允许定义两个方法名相同，并且参数签名也完全相同的方法。因为假如存在这样的两个方法，Java虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型、个数和顺序。
子类
1、 Java中类与类之间也有生活中类似的继承关系。在Java类继承关系中，对应于父亲的类叫父类，对应于儿子的类叫子类。父子类间的继承关系也叫“is a”关系。这种关系通过类声明上的extends关键字体现。
一个子类只有一个父类，一个父类可有多个子类。
2. 为什么要继承？
. 不修改源代码，修改既有类的行为；通过继承，在子类中构建父类中一样的方法，可以改变父类方法的行为。
3. Object类简略介绍
所有的Java类都直接或间接地继承了java.lang.Object类。Object类是所有Java类的祖先，在这个类中定义了所有的Java对象都具有相同行为。
十五. 继承
子类继承了父类的属性和方法：
1) 父子类同包，子类继承父类中public、protected和默认访问级别的成员变量和成员方法；
2) 父子类不同包，子类继承父类中public、protected的成员变量和成员方法；int a;这种声明方式的不能继承过来
那么继承有哪些细节呢？
1、构造器不能被继承：子类需要使用父类的构造器，需要super();
2、方法和实例变量可以被继承public方法
3、子类构造器隐式地调用父类的默认无参构造器;Student stu=new Student();
所以子类可以直接调用父类的方法，父类中有一个方法test();在子类方法中直接调用
4、如果父类中没有定义无参构造器，只定义了有参构造器，那么子类构造器则必须显式地调用父类的有参构造器(通过super(…))，且必须放置在第一条语句，否则会有语法错误。
注意是子类构造器中定义super(……);
5、this()和super()在构造器中都必须为第一条语句，两者不能同时出现。
6、当一个子类继承了一个父类后，父类中所有的字段和方法都被子类继承拥有，子类可以任意的支配使用，每个子类对象中都拥有了父类中的所有字段。当构造一个子类的实例对象时，该对象的实例变量包括了子类本身以及父类中的所有实例变量，实例方法也包括了子类和父类中的所有实例方法。
7、子类构造器用来初始化子类中所有的实例变量，而父类构造器super(实参)用来初始化父类中所有的实例变量。
所以在堆中为子类实例对象分配的内存区域中包括了子类和父类中所有初始化后的实例变量
package oneShiya;
/*
- @继承
- 在Java类继承关系中，对应于父亲的类叫父类，对应于儿子的类叫子类。父子类间的继承关系也叫“is a”关系。
- 这种关系通过类声明上的extends关键字体现。一个子类只有一个父类，一个父类可有多个子类。
- 所有的Java类都直接或间接地继承了java.lang.Object类。Object类是所有Java类的祖先，在这个类中定义了所有的Java对象都具有相同行为
- */
//super();调用父类的构造器
//super.name;调用父类的属性，方法.但是，调用的属性，方法必须是可以被继承下来的
/*1) 父子类同包，子类继承父类中public、protected和默认访问级别的成员变量和成员方法；
*2) 父子类不同包，子类继承父类中public、protected的成员变量和成员方法；少了默认的成员变量int a; int b; - 父类构造器不能继承，但是可以隐式调用父类的构造器：super调用父类的构造器，必须放在第一行，当
- public StudentSun(){
- super();
- }
- /
/ - 单继承
- Student中的public都可以继承过来
- /
public class StudentSun extends Student{
/- 子类中有和父类属性名字一样，构建子类对象调用子类对象
- 子类想调用父类的属性或者方法（子类中声明了父类的同名属性或者方法），用super.方法名【属性名】调用父类的
- 子类中和父类一模一样（修饰符，返回类型，方法名，参数【参数个数，类型，顺序】）的方法，叫做重写
- 重写的目的：将来构建的子类调用方法，调用的是子类的方法
- 静态方法不能被重写，子类不能将父类中的静态方法重写为非静态方法
- /
int a;
public static void main(String[] args) {
//子类生命对象
StudentSun stu=new StudentSun();
stu.a=5;
/- 1、父类指向子类，名字一样的公共属性（int a; int a;），这个时候调用的父类的属性
- 2、父类生命一个public void test(){}
-
调用test();这时调用的是父类的方法 - “父类指向子类”，子类重写父类的方法的时候，调用的方法是子类的，与属性不同，属性调用的是父类的
- */
//父类指向子类
Student stu1=new StudentSun();
}
}
方法覆盖（重写）
1. 方法覆盖只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被覆盖；
2. 静态方法：
不能覆盖；
a. 父类的静态方法不能被子类覆盖为非静态方法 //编译出错
b. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
例如:A类继承B类 A和B中都一个相同的静态方法test
B a = new A();
a.test();//调用到的时候B类中的静态方法test
A a = new A();
a.test();//调用到的时候A类中的静态方法test
可以看出静态方法的调用只和变量声明的类型相关
这个和非静态方法的重写之后的效果完全不同
c. 父类的非静态方法不能被子类覆盖为静态方法；//编译出错
3. 私有方法：
不能被子类覆盖
class Base {
private String showMe() {
return "Base";
}
public void print() {
System.out.println(showMe());
}
}
public class Sub extends Base {
private String showMe() {
return "Sub";
}
public static void main(String args[]) {
sub sub = new Sub();
sub.print();
//打印出结果"Base", 因为print()方法在Base类中定义，因此调用在Base类中定义的
//private类型的showMe(). 如将private换成public类型，其它代码不变，打印"Sub";
}
}
- 抽象方法：
可以覆盖：
a. 父类的抽象方法可以被子类覆盖为非抽象方法： 子类实现父类抽象方法；
b. 父类的抽象方法可以被子类覆盖为抽象方法： 重新声明父类的抽象方法；
c. 父类的非抽象方法可以被子类覆盖为抽象方法；
super关键字
1. 为什么要使用super关键字？
1）子类中要访问父类方法或变量。
2) 子类中调用父类的构造器
2. 使用注意事项：
a. 只能在构造方法或实例方法内使用super关键字，在静态方法和静态代码块内不能使用super关键字。
b. 在子类构造方法中如没有使用this关键字，会隐式调用父类的无参构造方法；
class Father() {
public Father() {
//这里第一行隐含一句代码: super();
System.out.println("In Father()");
}
}
class Son extends Father {
}
public class Test {
public static void main(String[] args) {
new Son(); //打印输出 In Father()
}
}
-----------------------------------------------------------------------
class Father() {
public Father() {
System.out.println("In Father()");
}
}
class Son extends Father {
public Son() {
System.out.println("In Son()");
}
}
public class Test {
public static void main(String[] args) {
new Son();
//打印输出 In Father()
// In Son()
}
}
-----------------------------------------------------------------------
class Father() {
public Father(String name) {
System.out.println("In Father() " + name);
}
}
class Son extends Father {
public Son() {
System.out.println("In Son()");
}
}
public class Test {
public static void main(String[] args) {
new Son(); //编译出错, 子类会隐式调用父类中无参构造方法，而此时父类中不存在无参构造方法。
}
}
-----------------------------------------------------------------------
class Father() {
public Father(String name) {
System.out.println("In Father() " + name);
}
}
class Son extends Father {
public Son() {
super("zs");
System.out.println("In Son()");
}
}
public class Test {
public static void main(String[] args) {
new Son();
//打印输出：
//In Father() zs
//In Son()
}
}
-----------------------------------------------------------------------
class Father() {
public Father() {
System.out.println("In Father()");
}
public Father(String name) {
System.out.println("In Father(String name)");
}
}
class Son extends Father {
public Son() {
this("zs");
System.out.println("In Son()");
}
public Son(String name) {
System.out.println("In Son(String name)");
}
}
public class Test {
public static void main(String[] args) {
new Son();
//打印输出：
//In Father()
//In Son(String name)
//In Son()
}
}
c. 构造方法中this(...)和super(...)不能同时出现；
多态
多态的俩中描述:
1.一个父类类型的引用可以指向他任何一个子类的对象
2.[相同]类域的[不同]对象执行[同一]方法的时候会有[不同]的表现
多态是出现在具有继承关系的两个类的对象之间，所以它不像方法重载（发生在一个类中）在编译期间发生（也就是确定下来），而是在运行期间发生（确定下来）。
Java中的方法是在代码运行时动态绑定的。
类型转换
转换：
1) 先使用instanceof 识别类型
2) 子类型隐式地扩展到父类型（自动转换）
3) 父类型必须显式地缩小到子类型
转换规则：被转换的实际对象类型一定是转换以后对象类型的自身或者子类。
Person p = new Person();
Student s = (Student)p; 编译不会错，运行时错误
Person p2 = new Student();
Student s = (Student)p2 或者 Person p = (Student)p2; 正确
225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
