面向对象(查漏补缺)

this关键字

this关键字的作用:解决局部变量和成员变量的二义性

用途:

1.在构造器中表示的是当前对象

2.在非static修饰的方法中表示的是调用者

3.this关键字还可以构造器重载互调

 1     public void setName(String name) {
        this.name = name;//this指向的是调用者
    }


public Person(String  age){
  this.( name , 0);//必须方法第一行,构造方法重载  
}

public Person(String name,int age){
   this.name=name;
   this.age=age;        
}

**同一个类中非static方法间互调（此时可以省略this，但是不建议省略）

super关键字

super表示的是当前对象的父类

作用:

1.子类构造器访问父类构造器(无参构造器默认生成super()在第一行)

2.子类方法覆盖父类方法后,还想调用父类方法时使用

 

public class Student extends Person {    
　　private String sn;


    public Student(String sn) {
        super();// 隐式调用父类无参数构造器,必须作为构造第一行
        this.sn = sn;
    }
    public Student(String name, int age, String sn) {
        super(name, age);// 去调用父类无参数构造器,必须作为构造第一行
        this.sn = sn;
    }
    public void doWork() {
        super.doWork();    //    ?此时调用谁的方法
        this.doWork();    //    ?此时调用谁的方法
        System.out.println("Student...doWork...");
    }
}

 

static修饰符

作用:有多个成员变量或方法需要时,可以用static修饰

static存储在方法区,被所用的对象共享

static修饰的直接对类负责,不属于该类对象

 

 **static虽然被所有对象共享,但不建议用对象调用(因为它其实还是需要去底层使用类名访问的)

public class Dog{
    private static String name;
    private int age;
    
    public static void walk(){
        System.out.println("跑");
    }
    
    public void eat(){
        System.out.println("chi");
    }
}

public class StaticDemo{
    public static void main(String[] args) {
        Dog d = new Dog();
        d.m2();//没用static修饰的字段和方法,都是对象 需要创建才能调用
//        Dog.m2();错误
        d.m1();
        Dog.m1();//静态写的方法,所有对象都可以共享,但是他是先调用底层方法,在去到方法区获取数据
//        Dog.m2();错误

        System.out.println(d.age = 20);
//        Dog.age
        System.out.println(d.num);
        System.out.println(Dog.num);
}

 

final修饰符

final的含义是最终的,不可改变,可以修饰类,方法,变量.

• final修饰的类：表示最终的类, 该类不能再有子类

• final修饰的方法：最终的方法, 该方法不能被子类覆盖

• final修饰的变量：表示常量，该变量只能赋值一次，不能再重新赋值。

• 基本数据类型:表示的值不能改变
• 引用数据类型:所引用的地址值不能改变

public /*final*/ class Person{//用final修饰的类,为最终类,不能被子类继承,从而修改方法
    public final int age=10;//final修饰的的变量,变为不会再被改变的常量
    
    
    public final void doWork(){//用final修饰的方法,无法再被覆盖重写
        System.out.println("go!go!go!");
    }
}

public class A extends Person{
    //public void doWork()final修饰方法无法覆盖
}

public class FinalDemo{
     public static void main(String[] args) {
         Person p=new Person();
         //p.age=100;无法修改
         final int[] arr={1,2,3};
        arr[0]=10;
         //arr=new int[4];final修饰的引用类型,无法修改它的地址值
         
     }
}

 

匿名内部类

这里只是简单介绍比较常用的匿名内部类,其实还有静态内部类,实例内部类,局部内部类等

匿名内部类又分为:

定义匿名内部类继承父类&定义匿名内部类来实现接口

public class Animal{
    public void puglin(IUSB iusb){
        iusb.doWork();
    }
    
    public void eat(){
        System.out.println("吃");
    }
}

public interface IUSB{
    void doWork();
}

public class AnonDemo{
    public static void main(String[] args) {
        Animal a=new Animal(){//操作继承关系,一般用来重写方法.当此方法不常用时就可以用匿名内部类
             public void eat(){
                System.out.println("吃饭");
            }
        };
        
        Animal b=new Animal()
        b.plugin(new IUSB(){//操作实例关系,对于不常用的直接匿名实现
             public void doWork(){
                System.out.println("吃饭");
            }
        };
    }
}

 

枚举类型的定义和使用

1.枚举类型是为了更方便的固定类只有那些对象

2.对类执行私有化,让其他类无法重新创建

3.变量用final修饰,让其他人只能依照我的规范

4.为每个成员变量创建对象

以下是我个人不用枚举类的麻烦过程.......

public Cloth{
    private static final int MEN=0;//当用final修饰的变量,命名规范所有字母大写,多个单词时用下划线分割
    private static final int WOMEN=1;//为了防止有人修改变量,所以用final修饰
    private static final int NORMAL=2;
    
    //每种衣服应该有单独的对象
    private ClothType type;
    //但这种方式还是不安全,有些人还可以重新new对象

　　public void setType(ColthType type){
　　　　this.type=type;
　　}

    
}

public ClothType{
    private static final ClothType  MEN=new ClothType();//对每个成员变量创建对象
    private static final ClothType WOMEN=new ClothType();
    private static final ClothType  NORMAL=new ClothType();
    
    private ClothType{}
}

public class ClothDemo {
    public static void main(String[] args) {
       Cloth c=new Cloth();
        c.setType(ClothType.MEN);
        //new ClothType();报错
        
    }
}

 这个其实是只是对没使用枚举时,所需要用到的步骤,方便进行对比与理解枚举的过程