目录
- 方法的重载和重写、构造器
- 1.java的修饰符：
- 2.普通方法
- 3.构造器（也叫构造方法/构造函数）
- 4.方法的重载
- 5.补充
- 6.方法的重写
- 7.类的执行顺序
- 8.再看方法的重写
方法的重载和重写、构造器
1.java的修饰符：
public修饰的代码，本类和其他类都是可以访问的
private修饰的代码，本类可以访问，但是其他类不可以访问的
2.普通方法
（1）方法是有访问权限的
（2）方法必须写上返回数据的类型，如果不需要返回数据就写void
void stu(){
System.out.println("学生好好学习");
return;
}
private int age(){
return 18;
}
（3）在同一个类当中，方法名可以相同但是方法的签名不能相同(方法的签名=方法名+参数列表的类型(string,int,double…))
例：
①
void stu(){
System.out.println("学生好好学习");
}
void stu(String name){
System.out.println("学生好好学习");
}
void stu(int name){
System.out.println("学生好好学习");
}
void stu(int name, String a){
System.out.println("学生好好学习");
}
②
void stu(int name){
System.out.println("学生好好学习");
}
void stu(int age){
System.out.println("学生好好学习");
}
（4）方法上可以用其他的关键字进行修饰，比如 static 和 final,他们有不同的意义
3.构造器（也叫构造方法/构造函数）
作用：在创建对象的时候给对象的变量赋值
(1).在类中构造函数必须和类名相同
(2).在类中有一个默认的不显示的无参数的构造器,
一旦你在类中写一个构造器，那么那个无参构造器就会被覆盖
(3).构造器不需要写返回值
(4).一个类中可以有多个构造函数
public class A {
private String name;
private int age;
private char sex;
private int sno;
public A(String name){
this.name=name;
}//这就是一个构造器
public A(String name,int age){
this.name=name;
this.age=age;
}
}
public class B {
public static void main(String[] args) {
A a=new A("张三");
}
}
4.方法的重载
发生在本类中; 在同一类中，方法名相同但是列表不同就是方法的重载；能提高方法的功能
这就是方法的重载：
public void stu(){
}
public void stu(String name){
}
public void stu(String name,int age){
}
5.补充
这个时候没有任何方法
这个时候可以调用很多方法
原因：
方法的执行流程是不断入栈出栈，一个方法想要入栈，只能被另一个方法调用，main方法本身就需要入栈
6.方法的重写
(1)发生在父子类当中，子类重新实现父类方法的功能
(2)为什么会重写？
继承的本质是代码的复用，在复用的过程中，父类的方法的实现不一定完全使用子类，这个时候就涉及到方法的重写
方法重写之后，子类对象调用的也是重写后的方法
重写前：
A：
public class A{
public void run(){
System.out.println("A跑的很快");
}
}
B：
public class B extends A{
}
Test：
public class Test {
public static void main(String[] args) {
B b=new B();
b.run();
}
}
运行：
重写后：
A：
public class A{
public void run(){
System.out.println("A跑的很快");
}
}
B：
public class B extends A{
public void run(){
System.out.println("B跑的很快");
}
}
Test：
public class Test {
public static void main(String[] args) {
B b=new B();
b.run();
}
}
运行：
7.类的执行顺序
static修饰的代码块在main方法执行之前执行，其目的是修饰 main方法
public class Test extends Base{
public Test(){
System.out.println("test constructor");
}
public static void main(String[] args) {
new Test();
}
static {
System.out.println("test static");
}
}
class Base{
static {
System.out.println("base static");
}
public Base(){
System.out.println("base constructor");
}
}
运行结果：
这样输出的原因：
先扫描再编译；先执行父类，再执行子类
程序执行先去找main()方法启动程序
1.扫描Test类，发现有父类Base类，先去扫描父类，发现Base类没有父类*
2.将Base.class加载进方法区，此时Base类中的static代码块执行*
3.将Test.class加载进方法区，此时Test类中的static代码块执行*
4，main方法入栈，main执行new Test();去创建Test类的对象*
5.创建子类对象之前先创建父类对象，所以先执行Base()构造器，再执行Test()构造器*
(1)先扫描Test,因为这里有main方法，扫描之后发现有父类Base，就扫描Base（直到没有父类为止）
(2)然后执行Base,static修饰的代码块在main方法执行之前执行，其目的是修饰main方法,所以先输出 base static,
(3)然后执行Test, 先执行static修饰的代码块，所以接下来输出 test static
(4)然后main方法入栈，调用Test(),创建子类对象，一定先去创建父类对象,所以先执行Base类的构造器，再执行Test类的构造器，所以接下来输出 base constructor,
(5)最后输出 test constructor
8.再看方法的重写
重写前
（子类访问不到父类私有的变量和方法）
重写后
(一旦发生重写，子类对象优先调用自身重写的方法)
