代码块

可视为一块代码,一般都是有{}括起来

局部代码块

一般由大括号 { }括起来，写在方法体中的,代码块就是局部代码块

class Test{//代码块
    public static void main(String[] args){
        {
            System.out.println("hello");//局部代码块
        }
    }
}

• 一般的在方法里面直接写{} 没有多大实际意义,结合
  if for来写才有意义

构造代码块

写在类中的代码块,无static修饰

class Test{//代码块
    public static void main(String[] args){
        new Test();//创建一次对象调用一次
        new Test();
        new Test();
    }
}
class Test{
    {
        System.out.println("我是构造代码块");//构造代码块
    }
}

• 声明在类中,创建对象的时候执行

静态代码块

直接写在类中,有static修饰的代码块

class Test{//静态代码块,在类加载的时候被执行
    public static void main(String[] args){
        System.out.println("hello");
    }
    //静态代码块优于主方法执行
    static{
        System.out.println("静态代码块就是我");
    }
}

• 声明在类中,在类被加载的时候执行

继承和组合关系

组合是在组合类和被包含类之间的一种松耦合关系，而继承则是父类和子类之间的一种紧耦合关系。

class Test{
    public static void main(String[] args){
        System.out.println("hello");
        Card card=new Card();
        card.setNum("13579246810");
        card.setZS("4G");
        CellPhone phone=new CellPhone();
        phone.setCard(card);
        System.out.println(phone.getCard().getNum());
        System.out.println(phone.getCard().getZS());
    }
}
class CellPhone{
    //私有化字段
    private String brand;
    private String color;
    private double price;
    private Card card;//将card作为字段声明在类中
    //定义公有的访问方法
    public void setCard(Card card){
        this.card=card;
    }
    public Card getCard(){
        return card;
    }
    void call(){
        System.out.println("疯狂打call");
    }
    void playGame(){
        System.out.println("我要抽SSR");
    }
}
class Card{
    private String num;//电话号码
    private String zs;//网络制式
    //公有的访问方法
    public void setNum(String num){
        this.num=num;
    }
    public String getNum(){
        return num;
    }
    public void setZS(String zs){
        this.zs=zs;
    }
    public String getZS(){
        return zs;
    }
}

枚举

//语法
enum 枚举名{
    字段
    方法
    构造方法--默认都是private修饰
}

实例

class Test{//枚举
    public static void main(String[] args){
        System.out.println("hello");
        System.out.println(SchoolArea.CQ);
    }
}
enum SchoolArea{//枚举
    CD("成都"),BJ("北京"),SH("上海"),GZ("广州"),CQ("重庆");
    String area;
    SchoolArea(String area){//构造方法
        this.area=area;
    }
    //覆写toString方法
    public String toString(){
        return area;
    }
}

• 一般枚举类型也是写在一个Java文件中，编译完毕也会生成字节码文件
• 每一个自定义的枚举类型都(隐式的)拓展至 Enum 类,因此我们的枚举对象可以调用到Enum中的方法的(看API )

接口

是一个和类很相似的结构

• 对于接口的理解:
  • 软件和软件之间数据交互的接口
  • java中的接口:和类很相似的结构

//语法
interface 接口名{
}

• 接口会独立生成一个字节码文件 没有构造方法

• 接口中可以有的成员:

  1. 字段：默认省略 public final static 修饰的
  2. 方法：如果没有修饰符的方法都是抽象方法不能有方法主体默认缺失public abstract
  3. 特殊情况:如果方法被static和default修饰 此时后可以有主体 jdk1.8的新特性

class Test6{//接口
    public static void main(String[] args){
        System.out.println("hello");
        System.out.println(Test.a);
    }
}

interface Test{
    int a=6;
    void eat();//接口里的方法为抽象方法
    //方法如果有static,default修饰则可以为普通方法
    static void run(){
    }
}
interface Test1{
}
interface Test2{
}
//一个类可以实现多个接口
//在同时有继承关系和接口实现时,要把继承的类写在前面,实现的接口写在后面
class Son extends Object implements Test,Test1,Test2{
    public void eat(){}
}

• 接口与接口之间支持允许继承
• 一个接口可以继承多个接口

class Test7{
    /*
        类是单继承,可以多层继承
        接口是可以多继承
        Son是T接口的实现类
        T接口是Son类的接口类
    */

public static void main(String[] args){
        System.out.println("hello");
    }
}
interface T1{
}
interface T2{
}
//接口多继承
interface T extends T1,T2{
}
//Son类实现了T接口
class Son implements T{
}