基本语法
- 类名 首字母大写
- 方法名 首字母小写
- 主方法入口 public static void main(String []args)
- 包名所有字母小写
- 常量，所有字母大写，单词间_ 链接
- void修饰时，不需要返回值
修饰符
- 访问控制，default public protected private
- 非访问控制， final abstract strictfp
变量
- 局部变量：方法、构造方法或语句中定义的变量，方法结束变量自动销毁
- 类变量（静态变量）：声明在类中，方法外，带static类型
- 成员变量（非静态变量）：无static，可被类中方法、构造方法访问
构造方法，一个类至少有一个，与类同名，作用是使类初始化
public class Pluto{
//类的构造器
public Pluto(){
}
public Pluto(String name){
}
}
关键字
| 关键字 | 描述 |
|---|---|
| abstarct | 抽象方法，抽象类的修饰符 |
声明规则
- 一个源文件中只有一个public类
- 源文件名称与public类名一致
- 如果类在某个包中，则package语句在首行
- import 在package和类定义之间，如果没package则import在首行
引包
import java.io.*;
this用法
- 调用本类中的成员变量
类型转换
int i = 64;
byte a = (byte)i;
(int)34.5 == 34;
变量类型
- 类变量：static int age = 16;
private static int age;
- 实例变量: 方法外，无static修饰
String id;
private String name;
- 局部变量：方法内
- 常量
final int age = 16;
访问修饰符(默认不带)
| 修饰符 | 当前类 | 同一包内 | 子孙类 | 其它包 |
|---|---|---|---|---|
| publict | Y | Y | Y | Y |
| protected | Y | Y | Y | N |
| default | Y | Y | N | N |
| private | Y | N | N | N |
修饰符
static修饰符
- 静态变量，局部变量不能带static修饰
- 静态方法，不能使用类的非静态变量
final修饰符
- 变量，通常与static一起创建类常量
- 方法，目的为了防止被修改，可以被子类集成
- 类，不能被继承
abstract修饰符
- 抽象类：不能被实例化，唯一目的是以后扩充
- 抽象方法
继承
关键字extends 类继承
class 子类 extends 父类{
}
关键字 implements 接口继承（可多个接口）
public class c implements a,b{
}
super & this
- super 调用父类的方法
- this 调用子类方法
构造器
- 子类不能继承父类的构造器
- 父类的构造器有参数时，必须super调用
多态
必要条件？？？
- 继承
- 重写
- 父类引用指向子类对象
多态是好处
例子
F1 按键在不同对象上产生不同结果，如word、浏览器等
实现方式
接口实现、继承父类进行方法重写，同一个类中进行方法重载
重载(@Overload)
一个方法名，不同参数，叫方法重载
void IDoor(String str);
void IDoor(Int number);
方法覆盖（@Override）
父类与子类同样的方法名和参数，叫方法覆盖
多态的例子
- 父类引用指向子类对象，调用方法时回调用子类的实现，而非父类实现叫多态
Parent instance = new Child(); //子类的实现
instance.foo(); //相当于Child foo()
- 花木兰从军
/**
* 定义父类，名叫花爹
*
*/
class huaDad{
/**
* 成员属性
*/
public String name = "huaDad";
public String sex = "男";
public Integer age = 50;
/**
* 定义"打仗"非静态成员方法
*/
public void toWar(int age){
System.out.println("打仗时的年龄是：" + age);
}
/**
* 定义"自我介绍"静态成员方法
*/
public static String selfIntroduction(){
return "Hello World!";
}
}
/**
* 定义子类，名为花木兰
*/
class Mulan extends huaDad{
public String name = "Mulan";
public String sex = "女";
public Integer age = 20;
public static String selfIntroduction(){
return "Hello My World!";
}
public void makeup(){
System.out.println("Beautiful!");
}
}
public class HelloWorldController {
public static void main(String[] args){
huaDad warrior = new Mulan();
System.out.println("年龄是：" + warrior.age);
System.out.println("名字是：" + warrior.name);
System.out.println("性别是：" + warrior.sex);
warrior.toWar(17);
//通过类名直接访问"静态成员方法"
System.out.println(huaDad.selfIntroduction());
System.out.println(Mulan.selfIntroduction());
Mulan ml = (Mulan)warrior;
//访问特有的成员方法时，需要强转换
ml.makeup();
}
}
多态的弊端
- 不能使用子类特有的成员属性和成员方法
封装
步骤
- 修改属性，限制访问
- 创建属性的对外访问方法
this关键字，解决实例变量和局部变量之间的同名冲突public void setAge(int age){ this.age = age }
接口（interface）
与类的区别
- 不能用于实例化对象
- 没有构造方法
- 方法均为抽象方法
- 不能被继承
- 支持多继承
接口的声明
/**
* 1、定义接口关键字：interface
* 2、接口中方法必须是公开方法
* 3、接口中方法不能有方法体，理解是方法嵌套方法
*/
public interface 接口名称 extends 父类1,父类2 {
//声明变量
//抽象方法
public void OpenDoor();
public void CloseDoor();
}
接口的使用，新建类来实现声明的接口
/**
* 1、实现接口关键字：implements
* 2、实现接口，必须实现接口中的所有方法
*/
public Class 接口名 implements 接口声明名{
@Override
public void OpenDoor(){
//重写的方法
}
@Override
public void CloseDoor(){
//重写的方法
}
}
目录结构
main/java
com.luojilab
config
facade
- 定义**Controller
