Java编程语言(新版)

Java 基本语法

2.2 Java 关键字

Java编程语言(新版)_第1张图片
50个Java关键字

"const"和"goto"无实际意义

Java 语言基础

2.4.1 变量

Java编程语言(新版)_第2张图片
变量表示范围

Java 运算符

2.2 位运算符

Java编程语言(新版)_第3张图片
位运算符

2.3 逻辑运算符

Java编程语言(新版)_第4张图片
逻辑运算符(短路)

Java 封装

2.3 访问修饰符

Java编程语言(新版)_第5张图片

2.5 内部类

内部类的主要作用如下:
1.更好的封装,内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
2.内部类的方法可以直接访问外部类的所有数据
3.内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便
4.内部类允许继承多个非接口类型
5.内部类的成员变量/方法名可以和外部类的相同

2.5.1 成员内部类

public class People {
    private String name = "LiLei";         //外部类的私有属性
    //内部类Student
    public class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name:" + name);
            System.out.println("访问内部类中的ID:" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        People a = new People();     //创建外部类对象,对象名为a
        Student b = a.new Student(); //使用外部类对象创建内部类对象,对象名为b
        // 或者为 People.Student b = a.new Student();
        b.stuInfo();   //调用内部对象的suInfo方法
    }
}

成员内部类的使用方法:
1.定义成员内部类后,必须使用外部类对象来创建内部类对象,即
内部类 对象名 = 外部类对象.new 内部类();
2.如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字
如上述代码中:a.this
3.成员内部类不能含有static的变量和方法,因为成员内部类需要先创建了外部类,才能创建它自己的。

2.5.2 静态内部类

package com.shiyanlou;

//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性

/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有
对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。
*/
    static String ID = "510xxx199X0724XXXX"; 

    //静态内部类Student
    public static class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name:" + (new People().name));
            System.out.println("访问外部类中的ID:" + People.ID);
            System.out.println("访问内部类中的ID:" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        Student b = new Student();   //直接创建内部类对象,对象名为b
        b.stuInfo();                 //调用内部对象的suInfo方法
    }
}

静态内部类是 static 修饰的内部类,这种内部类的特点是:
1.静态内部类不能直接访问外部类的非静态成员,但可以通过
new 外部类().成员 -------------的方式访问
2.如果外部类的静态成员与内部类的成员名称相同,可通过类名.静态成员访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过成员名直接调用外部类的静态成员
3.创建静态内部类的对象时,不需要外部类的对象,可以直接创建
内部类 对象名= new 内部类();

2.5.3 局部内部类

局部内部类,是指内部类定义在方法和作用域内。

package com.shiyanlou;

//外部类People
public class People {    
    //定义在外部类中的方法内:
    public void peopleInfo() {
        final String sex = "man";  //外部类方法中的常量
        class Student {
            String ID = "20151234"; //内部类中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex:" + sex);
                System.out.println("访问内部类中的变量ID:" + ID);
            }
        }
        Student a = new Student();  //创建方法内部类的对象
        a.print();//调用内部类的方法
    }
    //定义在外部类中的作用域内
    public void peopleInfo2(boolean b) {
        if(b){
            final String sex = "man";  //外部类方法中的常量
            class Student {
                String ID = "20151234"; //内部类中的常量
                public void print() {
                    System.out.println("访问外部类的方法中的常量sex:" + sex);
                    System.out.println("访问内部类中的变量ID:" + ID);
                }
            }
            Student a = new Student();  //创建方法内部类的对象
            a.print();//调用内部类的方法
        }
    }
    //测试方法内部类
    public static void main(String[] args) {
        People b = new People(); //创建外部类的对象
        System.out.println("定义在方法内:===========");
        b.peopleInfo();  //调用外部类的方法
        System.out.println("定义在作用域内:===========");
        b.peopleInfo2(true);
    }
}

局部内部类也像别的类一样进行编译,但只是作用域不同而已,只在该方法或条件的作用域内才能使用,退出这些作用域后无法引用的。

2.5.4 匿名内部类

匿名内部类,顾名思义,就是没有名字的内部类。正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写。但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口。


package com.shiyanlou;

public class Outer { 

    public Inner getInner(final String name, String city) { 
        return new Inner() { 
            private String nameStr = name; 
            public String getName() { 
                return nameStr; 
            } 
        }; 
    } 

    public static void main(String[] args) { 
        Outer outer = new Outer(); 
        Inner inner = outer.getInner("Inner", "NewYork"); 
        System.out.println(inner.getName()); 
    } 
} 
interface Inner { 
    String getName(); 
}

匿名内部类是不能加访问修饰符的。要注意的是,new 匿名类,这个类是要先定义的,如果不先定义,编译时会报错该类找不到。

同时,在上面的例子中,当所在的方法的形参需要在内部类里面使用时,该形参必须为final。这里可以看到形参 name 已经定义为final了,而形参city 没有被使用则不用定义为final。

Java 多态

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。

package com.shiyanlou;

class Animal {
    //父类方法
    public void bark() {
        System.out.println("动物叫!");
    }
}

class Dog extends Animal {

    //子类重写父类的bark方法
    public void bark() {
        System.out.println("汪、汪、汪!");
    }
    //子类自己的方法
    public void dogType() {
        System.out.println("这是什么品种的狗?");
    }
}


public class Test {

    public static void main(String[] args) {
        Animal a = new Animal();  // a是父类的引用指向的是本类的对象
        Animal b = new Dog();  // b是父类的引用指向的是子类的对象
        Dog d = new Dog(); 

        a.bark();
        b.bark();
        //b.dogType(); 
        //b.dogType()编译不通过
        d.bark();
        d.dogType();
    }

}

[图片上传失败...(image-42919e-1517733548046)]
由于b是父类的引用,指向子类的对象,因此不能获取子类的方法(dogType()方法),同时当调用bark()方法时,由于子类重写了父类的bark()方法,所以调用子类中的bark()方法。

因此,向上转型,在运行时,会遗忘子类对象中与父类对象中不同的方法,也会覆盖与父类中相同的方法——重写。(方法名,参数都相同)

你可能感兴趣的:(Java编程语言(新版))