目录

成员变量和局部变量

位置：

权限修饰不同：

初始化不同：

生命周期不同：（什么时候生（创建），什么时候死（销毁））

在内存中的位置不同：

抽象类，抽象方法

final关键字

接口

---

成员变量和局部变量

位置：

成员变量：在类中定义                                               局部变量：在方法中调用或者方法中的参数

权限修饰不同：

成员变量：可以使用权限修饰符（static）                 局部变量：不可以使用权限修饰符

初始化不同：

成员变量：

非静态---创建对象后，由构造方法初始化                  静态---类加载时初始化

局部变量：没有默认初始值，必须定义，赋值，使用前必须初始化

生命周期不同：（什么时候生（创建），什么时候死（销毁））

成员变量：随着对象的创建而存在，随着对象的销毁而消失   

               生（创建）                                   死（销毁）

非静态    创建对象                                       对象被垃圾回收

静态        类加载时                                       类被加载

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

               当方法被调用                                当方法执行结束              

在内存中的位置不同：

成员变量：与对象一起在对内存中 

非静态    与对象在对空间存储            

静态        与类信息在方法区中存储

局部变量：与方法一样在栈空间中存储

抽象类，抽象方法

只有方法声明（定义 public void test(）),没有具体的实现

Animal

   eat(){

         动物吃东西

   }

动物类型很大，在类体系结构位于上层，里面实现与大多数子类实现都可能不一样

在上层类中实现功能，就没有必要了，但是程序设计时，应该在上层定义这一类型应该有什么功能

然后让子类继承父类，在子类中对抽象方法进行重写

抽象类：被abstract关键字修饰的类，里面可能会包含抽象方法
                当类中没有足够的信息（抽象方法）来描述一个具体的对象时

                抽象类除了不能创建对象之外，类的其他功能都正常（成员变量，构造方法）

                抽象类一般位于类结构的上层，用来定义有哪些功能，让具体的子类继承实现即可

                静态的方法不能被修饰为抽象的方法的
                一个类中可以定义多个抽象方法的

抽象方法,定义方法，没有具体的实现，子类进行重写

package com.ffyc.javaopp.day4.cxl;public abstract class Animal {private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}public abstract void eat();public void sleep(){System.out.println("闭着眼睛睡觉");}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

  当一个具体的类继承抽象类后
    要么继承抽象类中抽象方法，
    要么将此类继续声明为抽象的类

package com.ffyc.javaopp.day4.cxl;//public abstract class Dog extends Animal{
public class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗吃骨头");}
}

package com.ffyc.javaopp.day4.cxl;public class TestAnimai {public static void main(String[] args) {//new.Animai.eat();new Dog().eat();}
}

final关键字

final关键字  可以修饰类，方法，参数，成员变量
  final不能修饰抽象类和接口，因为final修饰的类不能继承
  final修饰方法，修饰后方法不能被子类重写
  final修饰方法参数,在方法内部不能修改参数值
  final修饰成员变量

package com.ffyc.javaopp.day4.finaldemo;public class Demo {//情况一：在编码时，值就确定了，就直接进行赋值，此种情况最好加上static关键字，让其在内存中只有一份static final int num = 10;public final void test(final int a){//a = 10;}public static void main(String[] args){Demo demo = new Demo();demo.test(20);demo.test(30);//demo.num = 30; }}

package com.ffyc.javaopp.day4.finaldemo;public class T extends Demo{public T() {super();}
}

package com.ffyc.javaopp.day4.finaldemo;public class Demo {//情况一：在编码时，值就确定了，就直接进行赋值，此种情况最好加上static关键字，让其在内存中只有一份static final int num = 10;//情况二：每一个对象中都有一个常量，必须在构造方法中为常量进行初始化，一旦初始化，值都不能更改final int count;public Demo(int count) {this.count = count;}public final void test(final int a){//a = 10;}public static void main(String[] args){/*Demo demo = new Demo(count);demo.test(20);demo.test(30);*///demo.num = 30;new Demo(10);new Demo(20);}}

接口

  接口：
    是一种更为彻底的抽象，主要用来定义功能
    接口是不能被创建对象的，

    jdk8之后接口可以定义4中内容：
      1.静态常量
      2.抽象方法
      3.静态方法（jdk8之后才开始有的）
      4.默认方法（jdk8之后才开始有的）

package com.ffyc.javaopp.day4.jk;import java.io.Serializable;public interface MyInterface extends Serializable {int num = 10;//  public static final int num = 10;  静态常量void test();//  public abstract void test();  抽象方法//接口中定义静态方法，通过接口名直接访问public static void staticMethod(){}//默认方法，需要类继承，然后通过子类调用public default void test1(){}
}

package com.ffyc.javaopp.day4.jk;public class Test {public static void main(String[] args) {System.out.println(MyInterface.num);MyInterface.staticMethod();}
}

package com.ffyc.javaopp.day4.jk;import java.io.Serializable;/*类实现接口，一个类可以实现多个接口MyInterfaceImpl类是MyInterface接口的实现类*/
public class MyInterfaceImpl implements MyInterface, Serializable {@Overridepublic void test() {}public static void main(String[] args) {}
}