javase/java web技术要点-EW帮帮网

public static void main (String[] args) 详解

public static void main (String[] args) 是Java程序的入口方法，JVM在运行程序时，会先查找 main() 方法。

public 是权限修饰符，表明任何类或对象都可以访问这个方法。
static 表明mian()方法是一个静态方法，即方法中的代码是存储在静态存储区的，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过类名.main() 直接访问。
void 表明方法没有返回值。
main 是JVM识别的特殊方法名，是程序的入口方法。
字符串数组参数args 为开发人员在命令行状态下与程序交互提供了一种手段。

引申：

（1）main() 方法是否还有其他可用的定义格式？

static public void main (String[] args) —— public 和 static 没有先后顺序
public static final void main (String[] args) —— 可以定义为final
public static synchronized void main (String[] args) —— 可以上同步锁
不管用哪种定义方式，都必须保证 main() 方法的返回值为 void，并有 static 和 public 关键字修饰。同时由于 main() 方法为程序的入口方法，因此不能用 abstract 关键字来修饰。

（2）同一个 .java 文件中是否可以有多个 main() 方法？

虽然每个类中都可以定义 main() 方法，但是只有与文件名相同的用 public 修饰的类中的 main() 方法才能作为整个程序的入口方法。

class T {
   public static void main (String[] args) {
   System.out.println("T main");
}
}

// 必须是用 public 修饰，且类名与文件名相同的类中的 main() 方法才是入口。
public class Test {
   public static void main (String[] args) {
   System.out.println("Test main");
}
}
程序运行结果为：

Test main

方法：

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段

public class Demo {

float a;
//实例方法
void sum(float num1,float num2){
a = Max(num1,num2);
}

//类方法
static float Max(float num1,float num2){
//取最大值
return num1 <= num2 ? num2 :num1;
}

public static void main(String[] args) {
Demo demo =new Demo();
demo.sum(22,33); //实例方法必需先初始化类的实例，然后通过类的实例才能调用
Demo.Max(12,9); // 类方法可以直接通过类名调用

}

一个类中的方法可以互相调用。但要注意：实例方法可以调用该类中的其他方法，例如，sum()可以调用Max()。类方法只能调用其他类方法，不能调用实例方法。
类方法又叫静态方法，实例方法又叫非静态方法。
类方法可以直接通过类名调用，实例方法必需先初始化类的实例，然后通过类的实例才能调用

JAVA中的父类与子类

在java中，一个父类可以有多个子类，但是子类只能有一个父类。子类通常通过关键字extends来继承父类。

public class Animal {
int a = 3;
AnimalClass() {
System.out.println("父类无参构造函数")；
}

AnimalClass(int i) {
System.out.println("有一个形参i");
}
AnimalClass(int i,int j){
System.out.println("有两个形参i，j");
}
}
class DogClass extends AnimalClass {
int a;
int b;
public DogClass() {
System.out.println("123一起上");
}
public class DogClass(int a) {
this a = a;
System.out.println("456一起上");
}
public AnimalClass() {
super.(3,4);
}
public show() {
System.out.println("show 好!");
}
public static void main(String[] args) {
DogClass sc1 = new Dogclass ();
AnimalClass sc2 = new Animalclass ();
AnimalClass sc3 = new Animalclass (3,4);
}
}
这就是一个简单的父类与子类

implements:

extends 是继承父类，只要那个类不是声明final或者定义为abstract就能继承,Java中不支持多重继承，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了。

class A extends B implements C,D,E(){ //class子类名extends父类名implements接口名

}
覆盖：

一、Java中的方法覆盖
1.方法覆盖又称为方法重写，英语单词：override/overwrite
2.使用：
当父类中的方法已经无法满足当前子类的业务需求，子类有必要将父类中继承过来的方法进行重新编写，这个重新编写的过程称为方法的重写/覆盖
3.满足的条件：

方法的重写发生在具有继承关系的父子类之间
方法名相同返回值类型相同，返回值列表相同（尽量复制粘贴）
访问权限不能更低，可以更高
抛出异常可以更多，可以更少。
4.注意：

私有方法不能继承，所以不能覆盖。
构造方法不能继承，所以不能覆盖。
静态方法不存在覆盖。
覆盖只针对方法，不谈属性。

public class OverrideTest {
   public static void main(String[] args) {
       Animal a=new Animal();
       a.move();
       Cat bCat=new Cat();
       bCat.move();
       Bird bird=new Bird();
       bird.move();
   }
}

public class Animal {
   public void move() {
       System.out.println("动物在移动");

   }
}

public class Cat extends Animal{
   public void move() {
       System.out.println("猫在走猫步");

   }
}

public class Bird extends Animal{
   public void move() {
       System.out.println("鸟儿在飞翔");

   }
}

java中覆盖和重载的区别

1. 首先搞明白覆盖是什么？

· 举个栗子

public class Main {
   public static void main(String[] args) {
       new Father().print();
       new Son().print();
   }
}

class Father{
   public void print(){
       System.out.println("father");
   }
}
class Son extends Father{
   @Override
   public void print() {
       System.out.println("SON");
   }
}

2.重载是什么？

· 举个栗子

public class Main {
   public static void main(String[] args) {
       new Test().print();
       new Test().print(3);
       new Test().print(3,"双参");
   }
}

class Test{
   public void print(){
       System.out.println("无参");
   }
   public void print(int i){
       System.out.println(i+" "+"单参");
   }
   public void print(int i,String j){
       System.out.println(i+" "+j);
   }
}

该例子里写了多个print方法，但参数不同，因此可以运行，这也就是重载的含义，一个类中可以有多个同名不同参（参数列表不同）的方法。

final用法：

final关键字代表最终、不可改变的。
常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量

接口：

接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法

为什么要用接口
接口被用来描述一种抽象。
因为Java不像C++一样支持多继承，所以Java可以通过实现接口来弥补这个局限。
接口也被用来实现解耦。
接口被用来实现抽象，而抽象类也被用来实现抽象，为什么一定要用接口呢？接口和抽象类之间又有什么区别呢？原因是抽象类内部可能包含非final的变量，但是在接口中存在的变量一定是final，public,static的。
接口语法：