类小结1：方法重载 变量 封装 import 继承 重写父类方法 调用父类构造方法 多态

时间：2022-06-20 23:45:06

1.方法重载（两同、一不同）

  • 同一个类中方法名相同，参数列表不同
  • 方法返回值类型、修饰符等与方法重载没有任何关系
  • 不推荐重载 形参长度可变的方法，容易引起程序可读性低
  • 如果要想传入1个参数且执行  3，则采用new String[]{"qq"}方式
  • 同一个类的一个方法调用另外一个方法时，如果调用的是普通方法，则默认使用this作为调用者；如果被调用的方法是静态方法，则默认使用类来作为调用者。
  • 不使用static修饰的方法只能使用对象作为调用者来调，不能使用类作为调用者来调；

  • 使用static修饰的方法既可以使用类或者对象来调
public class Overload{
    public void test() //1
    {
        System.out.println("无参数");
    }
    public void test(String msg)//2
    {
        System.out.println("重载的test方法"+msg);
    }
    //此处形参长度可变的参数里不包含（没有参数和一个参数的形式）
    public void test(String... books)//3
    {
        System.out.println("形参长度可变的test");
    }
    public static void main(String[] args)
    {
        Overload ol = new Overload();
        ol.test();//执行1
        ol.test("123");//执行2
        ol.test("qq","23");//执行3
        ol.test(new String[]{"aa"});//执行3！！！ 注意
    }
}

2.变量

  • 成员变量：在类范围里定义的变量（实例变量：不用static修饰；类变量：用static修饰）
  1. 访问类变量：类名.类变量名  或  实例名.类变量名
  2. 访问实例变量：实例名.实例变量名
  3. 成员变量无需显示初始化，一旦类或实例创建之后就会有默认值
  • 局部变量：在一个方法或复合语句中定义的变量(形参，方法局部变量，代码块局部变量)
  1.  除了形参，方法局部变量和代码块局部变量定义的时候如果不初始化，则不能访问该变量
  • Java允许局部变量和成员变量同名，如果方法中局部变量和成员变量同名，则局部变量会覆盖成员变量，如果需要使用被覆盖的成员变量，则需用this或类名作为调用这来访问成员变量
public class Dog{
    public String name;//实例变量
    public static int eyeNem;//类变量 static修饰
}

3.封装(encapsulation)

  • 将对象的属性和实现细节隐藏起来，不允许外部直接访问
  • 把方法暴露出来，让方法来操作或访问这些属性
  • 以上两个步骤都需要Java提供的访问控制符来实现
  • 将对象的属性定义为private，除非一些static修饰的属性，然后通过方法setter和getter来操作对象的属性

4.访问控制符

  •  访问控制符级别：private->default->protected->public
  •  类只有两种访问控制符：public 和default
  •  default：可以被同包下其他类访问
  •  protected：被同包下其他类访问和被不同包中的子类访问
  •  public：可以被所有的类访问
  • java文件中如果有public修饰的类，则文件名需和public修饰的类名一致，否则会报错；如果没有public修饰的类，则java文件名只要合法即可。

    访问控制符的使用，存在如下规则：

  • 类中的绝大部分属性都应当定义为private，除了一些static修饰的、类似全局变量的属性，才可能考虑使用public修饰。除此之外，有些方法只是用于辅助实现该类的其他方法，这些方法被称为工具方法，也应该使用private属性
  • 如果每个类主要用作其他类的父类，则该类里大部分方法可能希望子类重写，而不想外界直接调用，则应该使用protected修饰这些方法
  • 希望暴露出来给其他类调用，则用public修饰。*类大部分都是用public修饰

5.import

  •     import package.subpackage...ClassName;//导入单个类
  •     import package.subpackage...*;//导入该包下所有类
  •     import static package.subpackage...ClassName.fieldName;//导入指定类的单个静态属性
  •     import static package.subpackage...ClassName.*;//导入类的所有静态属性

6.继承（inheritance）与派生（Derive）

  • java继承是单继承，即每个子类只能有一个直接父类，使用关键字extends
  • java的子类不能直接调用父类的构造方法；
  • 定义一个java类时并未显示指定这个类的直接父类，则这个类默认父类是java.lang.Object类，java.lang.Object类是所有类的间接父类或直接父类。

7.重写父类方法  方法覆盖（Override）

  • 子类包含与父类同名方法的现象，称为方法重写，或方法覆盖（Override）
  • 方法重写遵循“三同一小一大”
  • “三同”：方法名相同、形参列表相同、返回值类型相同；
  • “一小”: 子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
  • “一大“:子类方法的访问权限应父类方法更大或相等。
  • 注意：覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法。
  • 子类方法覆盖了父类方法后，子类对象无法访问父类中被覆盖的方法；但是，仍可以在子类方法中调用父类中被覆盖的方法。
  • 如需在子类方法中调用父类中的被覆盖方法，可以使用super(被覆盖的是实例方法)或着父类类名(被覆盖的是类方法)进行调用
  • super是直接父类对象的默认引用，this 和super都不能出现在static修饰的方法中；static修饰的属于类，因为该方法调用者是一个类而不是对象，因此也不存在父对象之说，因而super引用也就失去了意义。
  • 不管子类覆盖了父类的属性还是方法，都可以在子类方法中通过super引用来访问父类被覆盖的属性或方法

例1：重写形式

 下面的鸵鸟对象，将不再执行父类的fly()，而是执行本身重写的fly()

源文件：Bird.java

public class Bird{
    public int a = 7;
    public void fly()
    {
        System.out.println("我在飞");
    }
}
源文件： Ostrich.java
public class Ostrich extends Bird{
    public int a = 5;
    public void fly()
    {
        System.out.println("我只能在地上跑");
         System.out.println(a);//5
    }
    public static void main(String[] args)
    {
        Ostrich os = new Ostrich();
        os.fly();//执行Ostrich对象的fly()方法，将输出、、、
    }
}

例2：父类实例的super引用，即子类方法中调用父类被覆盖的方法
public class Ostrich extends Bird{
    ...//子类中原有的内容
    public void callOverridedMethod(){
        super.fly();//在子类方法中通过super显示调用父类被覆盖的实例方法
         System.out.println(super.a);//7
    }
    public static void main(String[] args)
    {
        Ostrich os = new Ostrich();
        os.fly();
        os.callOverridedMethod();//借助该方法调用被覆盖的fly方法，输出“我在飞”
    }
}

8.同一个类的方法中调用其他方法（普通方法和重载构造方法差异）

  • 同一个类的一个方法调用另外一个方法时，如果调用的是普通方法，则默认使用this作为调用者；如果被调用的方法是静态方法，则默认使用类来作为调用者。
  • 不使用static修饰的方法只能使用对象作为调用者来调，不能使用类作为调用者来调；
  • 使用static修饰的方法既可以使用类或者对象来调
  • 一个方法中调用其他的普通方法this.run()
  • 用this（""，""）代表重载的构造方法，此处说明调用两个参数的构造方法

例1:使用this来限定和区分是否是类变量
public class Car{
    public String name;
    public int oil;
    public Car(String name,int oil)
    {
        this.name = name;//使用this.name表示类变量，name表示方法变量
        this.oil = oil;
    }
    public void run(int speed)
    {}
    public void highRun(int speed)
    {
        int highSpeed = 2*speed;
        this.run(highSpeed);//一个方法中调用其他的普通方法this.run()
    }
}

例2：使用this关键字调用其他的重载方法  
public class Car{
    public Car(String name,int oil)
    {}
    public Car()
    {
        this("宝马","300");//用this（""，""）代表构造方法，此处说明调用两个参数的构造方法
        //Car("宝马","300"); //错误，因为这个方法要用new来调用
    }
}

9.子类中调用父类的构造方法

  • 在子类中调用父类的构造方法，一般使用super()调用来实现
  • this调用的是同一个类中的重载的构造方法；super调用父类构造方法，在子类中出现
  • 使用super调用父类构造方法时必须出现在子类构造方法执行体的第一行。
  • 不管是否使用super调用来执行父类构造方法的初始化代码，子类构造方法总会调用父类构造方法一次
  1. 子类构造方法执行体的第一行代码使用super显示调用父类构造方法；
  2. 子类构造方法执行体的第一行代码使用this显示调用本类中重载的构造方法，执行本类中另一个构造方法时即会调用父类的构造方法；
  3. 子类构造方法中既没有super也没有this,系统将会在执行子类的构造方法前，隐式调用父类无参数的构造方法；
  4. 总结：创建任何java对象，最先执行的总是java.lang.Object类的构造方法，创建对象总是从该类所在继承树最顶层的构造方法开始执行，然后依次向下执行，最后才执行本类的构造方法。如果某个父类通过this调用了同类中重载的构造方法，就会依次执行此父类的多个构造方法。
    class Base{
        public double size;
        public String name;
        public Base(double size,String name)
        {
            this.size = size;
            this.name = name;
        }
    }
    public class Sub extends Base{
        public String color;
        public Sub(double size, String name, String color)
        {
            super(size,name);
            this.color = color;
        }
        public static void main()
        {
            Sub s = new Sub(5.6,"测试对象","红色");
            System.out.println(s.size + ""+s.name+""+s.color)；
        }
    }

    10.多态性

    • 多态：指一个同名方法可能有多种版本在程序中同时存在，使用者使用同一个方法名调用方法，系统会根据具体情况，调用方法的不同版本，从而实现“一个接口，多个放法”。
    • 多态基础主要表现在：方法的重载和方法覆盖两方面。
    • 继承性和多态性降低了软件复杂性。
    • 父类的引用可以指向不同的子类对象，以实现不同的功能，这个方式就是多态。

Shape s1 = new Circle("圆形","32.5f");
Shape s2 = new Rectangle("矩形",3,5);
//Shape是父类，而可以通过父类的引用指向子类的对象，实现不同的功能

标签：

相关文章