Java 笔记 接口 抽象 和关键字

可爱的静静

抽象类的定义格式：
abstract class 类名
        {
                成员变量
                方法
                抽象方法
        }
成员方法 方法 抽象方法有，有没有根据自己需要来设计
        1、抽象类不能实例化，也就是不能new一个对象
        2、抽象类只能被继承
        3、抽象方法的定义格式：
                [修饰符] abstract 返回值类型 方法名(参数);
        4、一个类继承抽象类，就需要把抽象类中的抽象方法覆盖。否则这个子类也是抽象类，需要用
                abstract修饰


接口：
接口其实就是完全抽象的类，因此接口和类的地位是一样的，针对类的所有法则同样适用于接口。
接口所有的方法都是没有方法体的，而且所有方法都是默认public abstract  也就是接口那里面的方法全都是抽象方法，即使你没有这样声明，但默认是，接口是一个抽象类不能new  只能继承 而且要覆盖接口里的所有抽象方法，方法的访问全向必须大于或者等于父类抽象方法访问权限。而接口中的所有成员变量都是public static final的变量，并且必须要定义初始化，因为所有变量都必须在编译的时候有确定值。
接口定义的格式：
        interface 接口名
        {
                常量
                抽象方法
        }
有没有常量 抽象方法 都是根据自己需要定义
        1、接口不能被实例化，也就是不能new一个对象
        2、变量默认是：public static final可以省略
                要访问接口中的成员的格式：接口名.常量名
成员变量必须初始化，因为static修饰的所有变量都必须在编译的时候有确定值，final 就是修饰的变量一旦赋值就不可以改  而final修饰的。


        3、方法的定义格式：
                [public][abstract]返回值类型 方法名(参数);
                其中：public abstract可以省略  也就是方法全部都是抽象的 继承接口的子类必须全部继承方法
        4、一个类可以继承多个接口只继承一个父类
                class 子类 implements 接口1,接口2,...
                {
                        成员变量
                        方法
                }
类和接口的地位都一样
        5、可以把子类对象赋值给接口的引用，接口引用调用方法时执行的是子类的方法

编写2个接口： A和B；在接口A中有个方法void
printUp()；在接口B中有个方法void printLower ()；然
后写一个类Print实现接口A和B，要求printUp ()方法
实现输出大写英文字母表的功能，printLower ()方法实现输出小写英文
字母表的功能。

public class Test {
        public static void main(String[] args) {
                Interface  A  a = new Print();
a.printUp ();
                System.out.println();
                InterfaceB b = new Print();
                b.printLower();
        }
}
interface InterfaceA
{
        void printUp();
}
interface InterfaceB
{
        void printLower ();
}
class Print implements InterfaceA,InterfaceB
{
        public void printUp()

        {
                for(int i='A';i<='Z';i++)
                {
                        System.out.print((char)i + "  ");
                }
        }
        public void printLower ()
        {
                for(int i='a';i<='z';i++)
                {
                        System.out.print((char)i + "  ");
                }
        }
}

static关键字：
        static关键字可以用于修饰成员变量，称为静态变量还可以修饰方法   
                                        [修饰符] static 数据类型 变量名[=值]
                                可以用于修饰方法，称为静态方法
                                        [修饰符] static 返回值类型 方法名(参数)
                                        {
                                                方法体
                                        }

   
        静态成员类似于一个全局的变量，在内存中只有一个，被所有对象所共享

        静态成员属于类的，而非静态的成员是属于对象的


在另一类中来访问当前的类的成员：
        1、另一类来访问当前类的静态成员的格式：类名.成员
        2、另一个类来访问当前类的非静态成员的格式：对象名.成员

同一个类中的方法
        静态方法来访问成员：
                1、被访问的成员是静态，可以直接访问
                2、被访问的成员是非静态的，需要用 对象名.成员
        3静态方法只能访问静态成员
4静态方法中不可以写this，super关键字

        非静态方法访问成员变量
                1、被访问的成员是静态，可以直接访问
                2、被访问的成员是非静态的，直接访问的是自己对象的成员
                        若要访问其它对象的成员，则需要用 对象名. 成员变量
3静态方法可以访问静态和非静态变量
       

public class Test {
        public static void main(String[] args) {
                System.out.println(A.age);
                A a = new A();
                System.out.println(a.name);
                a.output();
        }
}
class A
{
        static int age = 12;
        String name="小妞";
        static void disp()
        {
                System.out.println(age);
                A b = new A();
                System.out.println(b.name);
        }
        void output()
        {
                System.out.println(age);
                System.out.println(name);
                A c = new A();
                System.out.println(c.name);
        }
}

final关键字
1、用final修饰变量，就为常量，就需要初始化，并且后面不可以修改
        public class Test {
                public static void main(String[] args) {
                        A a = new A();
                        System.out.println(a.age);
                        a.age=34;//error
                }
        }
        class A
        {
                final int age = 12;
               
        }

2、用final修饰方法，表示这个方法不能被覆盖
        class A
        {
                final void disp()
                {}
        }
        class B extends A
        {
                void disp()  //error
                {
                       
                }
        }
3、用final修饰类，表示这个类不能被继承
        final class A
        {
                 void disp()
                {}
        }
        class B extends A  //error
        {
                void disp()
                {
                       
                }
        }

佳阳

get