Java语言学习day 09 - 面向对象04(关键字修饰符内部类枚举)

本文链接：https://blog.youkuaiyun.com/qq_39551794/article/details/108026714

Java入门day 09 - 面向对象

1.面向对象

1.1 this 关键字

this: 当前对象.
this的位置: 1.构造器 2.方法中.
this. 变量名: 表示该变量是成员变量.

什么情况使用this:

解决局部变量和成员变量的之间的二义性.
同一个类中非static方法之间的调用.
构造器重载互调. (必须写在第一行).

1.2 super关键字

super: 当前对象的父类对象.

在创建子类对象时, 子类构造器会先去调用父类的构造器.

什么情况使用super:

子类方法中, 调用父类被覆盖的方法.
子类构造器中, 调用父类构造器. (必须写在第一行).

1.3 static修饰符

static 修饰的字段和方法属于类, 不属于该类的对象.

使用static 修饰的成员: 属于类直接类名加方法名调用.

不使用static 修饰的成员: 属于对象, 必须先创建对象, 在调用.

static: 不能使用super 和 this, 被所有对象共享.

最后记住结论:

类成员: 使用static修饰的字段和方法: 属于类直接使用类名调用即可.
实例成员：没有使用static修饰的字段和方法: 属于对象必须先创建对象，再调用.

public class Dog {
    //静态字段
    public static int totalNumber = 100;
    public int age;

    public void m1(){
        System.out.println("实例方法");
    }

    public static void m2(){
        System.out.println("静态方法");
    }
}

public class StaticDemo {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        d1.age = 5;
        d1.m1();
        d1.m2();
        //因为m1不是使用static修饰不能直接调用必须先创建对象再调用.
        //Dog.m1();
        Dog d2 = new Dog();
        d2.age = 10;
        d2.m1();
        d2.m2();
        因为m2使用static修饰能直接使用类名调用.
        Dog.m2();

        System.out.println(d1.totalNumber);
        System.out.println(d2.totalNumber);
        System.out.println(Dog.totalNumber);//静态字段
    }
}

1.4 final修饰符

final: 表示最终的, 不可改变的.
具体作用:

final修饰的类: 表示最终类, 该类不能再有子类.
final修饰的方法: 最后的方法, 该方法不能再被子类覆盖.
find修饰的变量: 表示常量, 该变量只能赋值一次, 不能再重新赋值.

   public class Dog {
       private int age;
   
       public Dog() {
       }
   
       public Dog(int age) {
           this.age = age;
       }
   
       public int getAge() {
           return age;
       }
   
       public void setAge(int age) {
           this.age = age;
       }
   }

public class FinalDemo {
    final public class Super{
    }
    //语法报错,final表示最终类,不能再有子类就是继承
//    public class Sub extends Super{
//    }
    public class Super1{
        final public void Work(){
        }
    }
    public class Sub extends Super1{
        //final是最终的方法,该方法不能被子类覆盖
//        public void Work(){
//        }
    }
    public static void main(String[] args) {
        final int age  = 17;
        //final修饰的变量：表示常量，该变量只能赋值一次，不能再重新赋值。
//        age = 10;
        final Dog d = new Dog();
        d.setAge(10);
        //所引用的地址值不能改变
//        d = new Dog();
    }
}

1.5 代码块

代码块: 使用{ }括起来的一段代码.
局部代码块: 直接定义在方法内部的代码块, 一般不会直接使用局部代码块, 都是结合if、while、for等关键字使用.

public class CodeBlockDemo {
    public static void main(String[] args) {
        //局部代码写法
        {
            int age = 100;
        }
//        System.out.println(age); //超出定义范围
    }
}

初始化代码块(构造代码块): 直接定义在类中. 每次创建对象都会执行初始化代码块, 开发中不使用, 一般我们初始化直接在构造器完成.
静态代码块: 使用static修饰的初始化代码块, 当该代码块的类的字节码被加载进 JVM, 就执行static代码块代码, 只执行一次. 在开发中, 通常用来加载资源, 加载配置文件等操作.

public class Fish {
    {
        System.out.println("初始化");
    }
    static {
        System.out.println("静态初始化");
    }
    public Fish(){
        System.out.println("无参构造器");
    }
    public static void main(String[] args) {
        System.out.println("main方法");
        new Fish();
        new Fish();
    }
}

1.6 内部类和匿名内部类

内部类: 把一个类定义在另一个类的内部, 把里面的类称之为内部类, 把外面的类称之为外部类.

内部类可以看作和字段、方法一样, 是外部类的成员, 而成员可以有static修饰.

静态内部类: 使用static修饰的内部类, 那么访问内部类直接使用外部类名来访问.
实例内部类: 没有使用static修饰的内部类, 访问内部类使用外部类的对象来访问.
局部内部类: 定义在方法中的内部类, 一般不用.
匿名内部类: 特殊的局部内部类, 适合于仅使用一次使用的类

对于每个内部类来说, Java编译器会生成独立.class文件.

静态和实例内部类: 外部类名$内部类名字-
局部内部类: 外部类名$数字内部类名称
匿名内部类: 外部类名$数字

1.6.1匿名内部类

匿名内部类: 如果一个类只需要在当前方法中使用一次, 就使用匿名内部类.
匿名内部类语法:
```
			new  父类/接口(参数 ){
              //匿名内部类的类体部分
			}
```
这里定义了一个类: 是制定的父类或者接口的子类/实现类.

使用上面创建的子类/实现类创建对象

特殊: 1. 就是一个类

		2. 少写一个java文件
     		3. 会生成一份字节码文件
     		4. 会创建对象

public class Animal {

    public void shout(){
        System.out.println("动物叫");
    }
}

public class AnimalDemo {

    public static void main(String[] args) {
        Animal a = new Animal(){
            public void shout() {
                System.out.println("青蛙不叫了");
            }
        };
        a.shout();
    }
}

1.7 枚举

枚举是一种特殊的类, 固定的一个类只能有哪些对象, 定义格式：

public enum  枚举类名{
      常量对象A, 常量对象B, 常量对象C ;
}

枚举中都是全局公共的静态常量, 可以直接使用枚举类名调用.

ClothType type = ClothType.MEN;

因为java.lang.Enum类是所有枚举类的父类,所以所有的枚举对象可以调用Enum类中的方法

String	name = 枚举对象.name();  		//	返回枚举对象的常量名称
int	ordinal  = 枚举对象.ordinal();	//	返回枚举对象的序号,从0开始

注意：枚举类不能使用创建对象

public enum ClothType {
    MEN, WOMEN, NEUTRAL;
}

public class ClothTypeDemo {
    public static void main(String[] args) {
        int ordinal = ClothType.WOMEN.ordinal();
        String name = ClothType.WOMEN.name();
        System.out.println(ordinal);
        System.out.println(name);
        new ClothType();	//语法报错
    }
}

2.总结

2.1 this的作用是什么？都有哪些用途？

this 的作用: 在构造器中, 表示当前被创建的对象. 在方法中, 表示调用的对象.

this 的用途: 避免成员变量和局部变量同名时的二义性. 构造器的调用, 必须放在构造器第一行. 调用同一个类中的非static方法.

2.2 super的作用是什么？都有哪些用途？

super作用: 调用父类的方法或者构造器.

super用途: 当子类覆盖了父类的方法时, 使用super去调用父类的方法. 当想用父类构造器时也可以使用super.

2.3 用static修饰的成员和不用static修饰的成员的区别？

用static修饰的成员属于类, 可以直接用类名调用也可以创建对象再使用但是不推荐. 使用static修饰的成员被所有对象共享.

不用static修饰的成员变量属于对象, 使用时必须先创建对象, 再使用

2.4 final能用在哪些地方，各自的作用是什么？

final用在修饰类, 方法, 变量时,表示最后的最终的.

final作用: 修饰类时: 表示最终类, 不可被继承, 就是不能再有子类.

修饰方法时: 表示最终的方法, 不能被子类覆盖.

修饰变量时:
基本数据类型时, 赋值后的值不能被改变

引用数据类型时, 引用的地址不能被改变

2.5 说说你对静态对象块的理解

使用static修饰代码块时, 静态代码块只会在该类的第一个对象被创建是执行一次, 且只会执行一次. 静态代码块可以调用静态方法.

2.6 什么时候可以使用匿名内部类？语法是什么？

匿名内部类: 就是一个没有名字的内部类, 当一个类只需被使用一次的时候, 我们可以使用匿名内部类, 减少一个java文件.

语法: new 父类/接口( 参数 ){

//匿名内部类的功能

}

2.7 什么时候可以使用枚举？说说他的语法

确定有多少个对象的时候可以使用枚举.

枚举语法:

public enum 枚举名{
	常量对象A, 常量对象N;
}