java基础面向对象 接口 包 内部类 3个关键字

接口   包  内部类    3个关键字
一.1.1
1.1)  接口的概念：
1.如果一个类中只有抽象方法，我们可以将这个类定义为"接口"，使用interface关键字；
2.一个接口中，只能包含常量、抽象方法，不能有实现的方法；(JDK8之后，可以有)；
3.接口同抽象类的作用一样，就是用来被子类"实现"的。
 区别：一个类只能继承自一个抽象类；
       一个类可以同时实现多个接口；
1.2)接口的特点：


1.接口不能被实例化，是用来被"实现"的；
2.一个子类可以同时实现多个接口；
3.当一个子类实现接口时，必须要重写接口中的所有抽象方法，否则，这个子类必须是个"抽象类";
 也就是说一个抽象类可以实现一个接口；
4.多态：
父类的多态：
class A{
}
class B extends A{
}
main(){
A a = new B();
}
抽象类的多态：
abstract class A{
}
class B extends A{
}
main(){
A a = new B();
}
接口多态：
interface IA{
}
class B implements IA{
}
main(){
IA a = new B();
}
5.接口中能够包含什么？
1.成员变量：只能是静态常量：被修饰为：public static final。
           我们在接口中可以不写上面的关键字，但系统会自动为我们添加：
interface IA{
int a = 10;//可以的。系统会自动添加：public static final int a = 10;
}
 我们以后很少在接口中定义成员变量；
2.成员方法：只能是"抽象方法"，被修饰为：public abstract。
           我们在接口中定义方法，可以不写上面的关键字，但系统会自动为我们添加：
interface IA{
int a = 10;//可以的。系统会自动添加：public static final int a = 10;
void show();//可以的，系统会自动添加：public abstract 
}
1.3) 抽象类和接口的共同点：
1.抽象类和接口都不能被实例化，都是给子类用的；

抽象类和接口的区别：


1.定义的区别：
抽象类：abstract class Xxxx
接口： interface Xxxx
2.成员的区别：
抽象类：成员变量、实现的成员方法、构造方法、抽象方法、静态成员；
接口： 成员变量(静态常量)，抽象方法：
成员变量：public static final
抽象方法：public abstract
3.关系区别：
抽象类：一个类"继承"一个抽象类，单继承；
接口：一个类可以同时实现多个接口。
4.设计理念的区别：
抽象类：is a (是一个)
接口：like a (像一个....)
二  2.1  包的定义：


1.使用关键字：package
2.格式：package xxx.yyy.zzz;
会把当前java文件编译的class文件存储在当前项目目录下的：xxx文件夹/yyy文件夹/zzz文件夹下
3.package语句一定是你当前文件的第一条可执行的代码;
4.package语句只能有一条；
5.java的类可以没有package语句，表示默认包，当前项目的根目录；


6.带包的编译：在控制台下，使用:javac -d . Xxxx.java
7.运行带包的类：java aaa.bbb.ccc.ClassName
2.2    一般定义包：com.公司名/项目名.模块名/开发小组


此Demo类被定义在：com.itcast.demo包下，它要访问：com.itcast.util.MyMath类；


怎么访问：
1.全名限定(带包名的类名)的使用其它包的类，这种方式需要写的内容很长，很不方便；
2.(掌握)导入包：使用关键字：import
格式：import xxx.yyy.zzz.(类名)
3.当使用一个包下的多个类时，可以写多条import语句；(推荐的方式)
 另一种方式：使用通配符*(不推荐)
4.当我们需要使用多个包下的同名类时：
1.两包下的同名类：建议，导入一个，另一个使用"全名限定的类型"
2.多个包下的同名类：全部使用"全名限定的类名"
2.3  可以通过使用"访问修饰符"来控制其它包下的类对本类访问的有些限制：


1.Java提供的访问修饰符：
1).public：公有的。任何包下的类都可以访问；
2).protected:受保护的：通常是在包内访问。在保外：它的子类可以访问；
例如：一个方法是受保护的。那么这个方法只能被同包下的其它类访问。
     如果在包外，只能是这个类的子类可以访问；
3).(默认)：只在同包下允许访问；
4).private:私有的。只能类的内部被访问；
2.访问修饰符的应用位置：
1).类：public 和 (默认)
2).成员变量和成员方法：
我们的例子主要是针对成员变量和成员方法；
2.4  内部类：


1.之前我们知道在类中可以定义：成员变量和成员方法，构造方法，代码块、静态代码块，其它静态成员
2.在类中，还可以定义一个类，这个定义在内部的类，就叫：内部类；
class A
{
//成员内部类
//如果内部类被修饰为private，意味着这个内部类只能在此类内部被使用；


private class B
{
}
//内部类可以被修饰为staitc的，为了外部方便实例化，不需要外部类的对象引用
//一个静态的内部类，如果要访问外部类的成员，那么只能访问外部类的静态成员；静态的只能访问静态；
//一个静态的内部类，可以包含静态方法和非静态方法；
//如果一个内部类包含了静态成员，那么这个内部类必须被声明为静态的；
 2.4 .1 匿名内部类：


1.先考虑在方法中，怎样返回一个局部内部类的引用？
2.可以获取的，但要内部类实现一个外部定义的一个接口或者抽象类或者父类
interface IA
{
void show();
}
class MyClass
{
public void fun(IA obj){
obj.show();
}
}
class Demo 
{
public static void main(String[] args) 
{
MyClass c = new MyClass();
//在这里使用"匿名内部类"的方式实现；
c.fun(new IA(){
//重写接口中的show方法
public void show(){
System.out.println("匿名内部类的show()");
}
});
}
}


一、static 关键字
          可以修饰：
          1.属性 --> 被static关键字修饰的属性叫类变量，是全类共有的，可直接用类名访问。
                     初始化类变量是在类加载是完成。
                类加载：当虚拟机JVM第一次使用一个类时，会通过classpath找到这个类所对应的
                        字节码文件，将这个文件中包含的类信息全读入JVM并保存起来，使下次再用
                        这个类时就不需要再去加载，一个类只加载一次。
        
          2.方法 --> 被static关键字修饰的方法叫静态方法，可直接用类名访问。
              
               静态方法的特点：
                            （1）静态方法只能访问类的静态成员（静态属性和静态方法）
                            （2）静态方法只能被子类中的静态方法覆盖，并且没有多态
                     例子：A a=new B(); A类是B类的父类
                           A中有m()方法，B中也有m()方法，则a.m()调用的是B中的m()方法；
                           如果A、B中的m()方法都是静态方法，则a.m()调用的是A中的m()方法
         
          3.静态代码块
                      在类加载时运行一次
 
二、final关键字
          可以修饰：
          1.变量 --> 被final修饰的变量成为常量，一旦赋值，不能被修改。
          2.方法 --> 如果一个方法被final修饰，说明该方法不能被子类覆盖 
          3.类 -->   如果一个类被final修饰，说明该类不能被继承
 
三、abstract 抽象的
         可以修饰：
          1.类 --> 不能创建对象，但可以声明对象的引用 
          2.方法 --> 只有定义，没有实现
               （1）如果一个类中有抽象方法，则这个类必须是抽象类
               （2）子类继承一个抽象类，如果子类不希望也成为抽象类，
                    就必须实现父类中所有的抽象方法
               （3）抽象类中有构造方法