方法:
1、定义:
修饰符 方法返回类型 方法名(参数类型 方法参数) {}
2、方法的调用
一个方法建议只做一个功能,如果让方法可传递不同的参数,可使用下边方法的重载。这里在记录一次,如果直接调用方法那方法前边必须加上static,使其变为类方法。
public class T {
public static void main(String[] args) {
totalTax(); // 调用类方法
}
// 必须加上static,否则它是一个实例方法,需要实例调用
public static void totalTax() {
//··· ···
return xxx; // 通过return 返回值
}
}
3、可变参数(java1.5)
当参数不确定是几个时,可使用可变参数表示,且只能放在参数的最后边
public class t {
public static void main(String[] args) {
test("1", "2", "3");
}
public static void test(String... params) {
System.out.println(params[0]); // "1"
System.out.println(params[1]); // "2"
System.out.println(params[2]); // "3"
}
}
4、命令行传参(理解)
顾名思义,可在命令行传递多个参数参数与参数之间用空格隔开,通过Main方法中的形参获取到传递的参数:
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println(i + ":" + args[i]);
}
}
构造方法:
1、构造方法类似ES6中的constructor,用来初始化
特殊地方:
(1)构造方法名称就是类名;
(2)构造方法没有返回值(也没有void);
(3)必须使用new操作符。
public class t {
public static void main(String[] args) {
Person person = new Person("lxc", 20);
}
}
class Person {
String name; int age;
public Person(String name, int age) { // 类型的构造方法,类似js中的constructor
this.name = name;
this.age = age;
}
}
2、默认构造方法
(1)任何class都有构造方法;
(2)如果一个类中没有编写构造方法,编译器会自动为我们生成一个默认构造方法,没有参数,也没有执行语句:
class Person {
public Person() {
}
}
(3)如果定义了构造方法,那么,编译器不再会自动创建默认构造方法。
(4)如果在初始化时,没有传入初始化的字段,引用类型字段的默认值为null,数值类型字段的默认值:int类型为0,布尔类型默认值为false:
public class t {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
class Person {
private String name;
private int age;
private boolean voids;
public void show() {
System.out.println(this.name + "," + this.age + "," + this.voids); // null,0,false
}
}
(5)补充:
类中如果存在未初始化的实例变量,代码执行时默认会在无参构造中,给实例变量赋值默认值。比如:如果是int类型,赋值默认值为0,布尔类型默认值为false。
方法重载:
定义:
在一个类中,我们可以定义多个方法。如果有一系列方法,它们的功能都是类似的,只有参数有所不同或参数不同且返回值不同,那么,可以把这一组方法名做成同名方法,方法名相同,参数不同成为方法的重载。
public class t {
public static void main(String[] args) {
Person person = new Person();
person.say("lxc;"); // say方法重载
}
}
class Person {
public void say(String name) {
System.out.println(name);
}
public void say(int age) {
System.out.println(age);
}
public void say(boolean voids) {
System.out.println(voids);
}
public String say() {
return "123";
}
}
继承
1、使用extends关键字来实现继承
class Person {
public String name;
private int age; // 私有字段不会被子类继承
protected String address;
}
class Son extends Person {
private int height;
public void say() {
System.out.println(this.name);
}
}
几个重点:
(1)如果一个类没有明确些extends,编译器会自动加上Object,所有任何类,除了Object,都会继承自某个类,Object没有父类。
(2)子类无法访问父类的private字段或private方法,这使得继承的作用被削弱了。为了让子类可以访问父类的字段,我们需要把private改为 protected,用protected修饰的字段可以被子类访问到。
2、super
super关键字表示父类(超类),子类引用父类的字段,可以用 super.fildName
class Person {
public String name;
protected String address;
}
class Son extends Person {
private int height;
public void say() {
System.out.println(super.address); // null
}
}
实际,上边使用 super.address 或this.address 或 address 效果都是一样的。但是某些特殊情况下,必须使用super。
// 以下是错误代码!
class Person {
protected String name;
public Person(String name) {this.name = name;} // person的构造方法
}
class Son extends Person {
private int height;
public Son(String name, int height) {
this.height = height;
}
}
任何一个类的构造方法在初始化时,第一行语句必须是调用父类的构造方法,像上边Son继承Person类,但是没有写super(),此时编译器会帮我们自动加一句super(),所以Son类中代码实际上是这样的:
class Person {
public Person(String name) {this.name = name;}
}
class Son extends Person {
private int height;
public Son(String name, int height) {
super()
}
}
但是,问题来了,父类Person并没有无参的构造方法,因此,编译会失败!解决此问题需要手动调用父类的构造方法:
class Person {
protected String name;
public Person(String name) {this.name = name;} // person的构造方法
}
class Son extends Person {
private int height;
public Son(String name, int height) {
super(name); // 显示的调用父类的构造方法,且需要传递参数
this.height = height;
}
}
几个重点:
(1)如果父类有构造方法,且有传参,子类必须显示的调用 super() ,并传递参数以便让编译器定位到父类的构造方法。
(2)子类不会继承任何父类的构造函数,子类默认的构造函数是编译器生成的。
(3)子类继承父类,如果要显示的调用super(), 那么必须放在构造方法的第一行!!!
加载顺序
1、
package com;
// 输出:1 -> 0 -> 2 -> 4 -> 3
public class Test {
{
System.out.println("0");
}
static {
System.out.println("1");
}
{
System.out.println("2");
}
public static void main(String[] args) {
new Test();
System.out.println("3");
}
public Test() {
System.out.println("4");
}
}
2、笔试题
考察点:
(1)静态变量只会初始化(执行)一次。
(2)当有父类时,完整的初始化顺序为:
父类静态方法(静态代码块) -> 子类静态变量(静态代码块) -> 父类非静态变量(非静态代码块) -> 父类构造器 -> 子类非静态变量(非静态代码块) -> 子类构造器。
public class Ints {
public static void main(String[] args) {
A a = new A();
a = new A();
}
}
class A{
static {
System.out.println("A");
}
public A() {
System.out.println("a");
}
}
class B extends A{
static {
System.out.println("B");
}
public B() {
System.out.println("b");
}
}
// 输出的顺序:A -> B -> a -> b -> a -> b
多态
放在下一篇记录。