基本语法

• 类名 首字母大写
• 方法名 首字母小写
• 主方法入口 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用法

1. 调用本类中的成员变量

类型转换

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）

父类与子类同样的方法名和参数，叫方法覆盖

多态的例子

1. 父类引用指向子类对象，调用方法时回调用子类的实现，而非父类实现叫多态

  Parent instance = new Child(); //子类的实现
  instance.foo(); //相当于Child foo()

2. 花木兰从军

  /**
 * 定义父类，名叫花爹
 *
 */
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

guessyoulike

utils

ApiMian

test