目录
一、构造方法
跟类名相同的方法名
被称作构造方法
,其作用是用于当一个类被new成对象时,对象需要声明的一些变量的构造声明。
1、构造方法的特点:
(1)构造方法的名字必须与定义他的类名完全相同(甚至连void也没有),且没有返回类型;
(2)构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象
。
Person p = new Person(); : person() 调用的就是Person的构造方法。
(3)每个类可以有零个或多个构造方法;
(4)不能被static、final、synchronized、abstract和native修饰。且构造方法不能被子类继承。
(5)构造方法在创建对象时自动执行
,一般不能显式地直接调用。
2、构造方法分类
(1)默认构造方法 ----老马 p59
// 无参构造方法
class Banana{
public Banana() { System.out.println("无参的构造方法被调用,这里是香蕉"); }
}
public class text3 {
public static void main(String[] args) {
Banana s = new Banana();
}
}
从代码和结果可以看出,“new Banana()” 除了实例化对象,还调用了构造方法Banana();
一旦定义了构造方法,Java就不会再自动生成默认构造方法。
如果只定义了第二个构造方法(带参数的),则下面语句:
Point p = new Point();
就会报错,因为找不到不带参数的构造方法。
(2)带参数的构造方法
// 有参构造方法
class Apple{
int size;
public Apple(int a) {
System.out.println("有参的构造方法被调用,这里是苹果");
size = a;
}
public void shuchu() { System.out.println("这个苹果有" + size + "这么大"); }
}
public class text3 {
public static void main(String[] args) {
Apple apple = new Apple(18);
apple.shuchu();
}
}
- 从代码和结果可以看到
Apple(int a)
这是一个有参的构造方法,在new Apple(18)
实例化对象的同时,把参数传给a赋值给size并调用了shuchu()这个构造方法。
(3)私有构造方法:修饰符为 private
场景:
1)不能创建类的实例,类只能被静态访问,如Math、Arrays类,它们的构造方法就是私有的。
2)能创建类的实例,但只能被类的静态方法调用。单例场景。
3)只是用来被其他多个构造函数调用,用来减少重复代码。
3、构造方法的重载
/*
* 构造方法的重载
*/
class Food{
String name;
int size;
public Food(String b , int a) { // 构造函数
name = b;
size = a;
}
public Food(String b) {
name = b;
}
public Food(int a) {
size = a;
}
public void shuchu() {
System.out.println("这个" + name +"有" + size + "这么大");
}
}
public class text4 {
public static void main(String[] args) {
Food s = new Food("苹果");
Food x = new Food("草莓",18);
Food z = new Food(20);
s.shuchu();
x.shuchu();
z.shuchu();
}
}
4、构造方法中的 this
this的第1种用法:this 表示当前实例;
this的第2种用法:调用第2个构造方法;
new Point() 的时候:
(1)分配存放实际数据的内存;
(2)给实例变量设置默认值,new Point() 设置的默认值为0;
(3)调用构造方法(构造函数);
public class Point() {
private int x;
private int y;
public void setX(int x) {
this.x = x; // this.x为实例变量x(无static修饰,能够被实例继承), 右侧的x为方法参数中的x
} // this的第一种用法:this表示当前实例
public void setY(int y) {
this.y = y;
}
public Point() {
this(0, 0); //this的第2种用法:调用第2个构造方法,并传递参数 "0,0"
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
----《Java编程的逻辑》马俊昌 p59
二、类方法、类变量、实例方法、实例变量
(1)类方法:static修饰,静态方法,静态方法是没有this的方法。
(2)类变量:static修饰,静态变量。
(3)实例方法
(4)实例变量
与static相对应的是【实例变量】【实例方法】,没有static修饰符。
Arrays类就只有类方法。 ----《Java编程的逻辑》p54
三、类方法(静态方法,用static修饰的方法)
静态方法
是属于整个类的,所以静态方法
的方法体中,不能有 与类的对象有关的内容(实例对象、实例方法
是属于类的对象)。即类方法体有如下限制:
静态方法
只能访问静态变量
,不能访问实例变量
,可以调用其他的静态方法
,不能调用实例方法
。
注释:IDEA中调代码时,main方法就是静态方法,也只能访问静态方法、静态变量。
实例方法
既能访问实例变量
,也能访问静态变量
,既可以调用实例方法
,也可以调用静态方法
。 ----《Java编程的逻辑》p55
规定:使用类名来调用静态方法,而不要使用实例或表达式来调用。 ----《Java核心技术 卷I》p117、Java语言编程规范
静态方法
不能被覆盖(重写)
;静态方法
中不能使用super,this
关键字;实例方法
中可以调用静态方法
;实例方法
中可以使用super,this
关键字;
四、类方法与实例方法的区别
静态方法
在加载类时就被分配了内存地址,因此加载后即可被任意对象调用,并且可以通过类名直接调用(类名.方法名)。实例方法
需要在创建对象后才会被分配内存地址,所以实例方法不能通过类名调用。
五、继承和多态
(1)每一个类有且只有一个父类
,没有声明父类的,其父类为Object。
(2)子类继承了父类非private
的属性和方法,可以增加自己的属性和方法,以及重写父类的方法实现。
(3)在 new
的过程中,父类先进行初始化。
(4)
public class Base {
public static String s = "static_base";
public String m = "base";
public static String s_static_base = "s_static_base";
public String m_base = "m_base";
public static void staticTest() {
System.out.println("base static.");
}
public void notStaticTest() {
System.out.println("base not static.");
}
public void notStaticTest_base() {
System.out.println("base_not_static_base.");
}
private void privateTest() {
System.out.println("base private.");
}
}
package org.example;
public class Child extends Base{
public static String s = "static_child";
public String m = "child";
public static String s_static_child = "s_static_child";
public String m_child = "m_child";
public static void staticTest() {
System.out.println("child static.");
}
public void notStaticTest() {
System.out.println("child not static.");
}
public void notStaticTest_child() {
System.out.println("base_not_static_child.");
String s = m_base;
}
private void privateTest() {
System.out.println("child private.");
}
}
public class Test {
public static void main(String[] args) {
Child c = new Child();
Base b = c;
// 重名 静态绑定: 实例变量、静态变量、静态方法、private方法。
// 重写:只用作实例方法(没有static修饰的方法, 属于实例对象的方法,实例对象可对其进行重写。)
// "public VS private"
System.out.println(b.s); // static_base
System.out.println(b.m); // base
System.out.println(c.s); // static_child
System.out.println(c.m); // child
// 实例变量、继承:子类中找不到,就调用父类变量、方法
System.out.println(b.m_base); // m_base(静态绑定)
// System.out.println(b.m_child); // error: Base 中找不到 m_child,不会到子类中去查找:显然不会到子类中去查找。
System.out.println(c.m_child); // m_child(静态绑定)
System.out.println(c.m_base); // m_base
// 子类中没有这个 实例变量,就到父类中寻找。
// 静态变量
System.out.println(b.s_static_base); // s_static_base(静态绑定)
// System.out.println(b.s_static_child); // error: Base 中找不到 s_static_child
System.out.println(c.s_static_child); // s_static_child(静态绑定)
System.out.println(c.s_static_base); // s_static_base
// 子类中没有这个 静态变量,就到父类中寻找。
// 静态方法
b.staticTest(); // base static.(静态绑定)
c.staticTest(); // child static.(静态绑定)
// private方法: 只能在类中访问,不能在外部访问
// b.privateTest(); // error
// c.privateTest(); // error
// 实例方法(属于实例对象的方法):被重写(子类重写与父类相同参数签名的方法)
b.notStaticTest(); // child not static.
c.notStaticTest(); // child not static.
// 实例方法:继承
b.notStaticTest_base();
// b.notStaticTest_child(); // error 找不到
c.notStaticTest_child();
c.notStaticTest_base(); // 子类中没有这个 实例方法,就到父类中寻找。
// 子类继承父类非private的属性和方法(实例变量、实例方法、静态变量、静态方法)
// 静态绑定执行后,在子类中找不到的属性、方法,就到父类中找;父类不能反过来。
// 静态变量、静态方法一般通过类名访问、但是也可以通过类的对象访问。
}
}