Java基础——面向对象编程（重载、重写、封装）

Java基础知识图解

重写与重载

重写：

参数与返回值相同，权限不能小于所覆盖的方法，抛出的异常不能大于多于所覆盖的方法。

class Cirlce{
   //求圆的面积
    public double findArea(){
   
    }

}

class Cylinder extends Circle{
      //求圆柱的表面积
      public double findArea(){
      }
}

重载

方法名相同，参数不同（数量、类型、顺序），与访问权限修饰符返回类型无关也就是可以不同。

   //定义两个int型变量的和
    public int getSum(int i, int j) {
        return i + j;
    }

    //定义三个int型变量的和
    public int getSum(int i, int j, int k) {
        return i + j + k;
    }

    //定义两个double型数据的和
    public double getSum(double d1, double d2) {
        return d1 + d2;
    }

重写（override orverwrite） vs 重载（overload）

重载：“两同一不同”：同一个类，同一个方法名，不同的参数列表。 注：方法的重载与方法的返回值无关！
>构造器是可以重载的
重写：（前提：在继承的基础之上，子类在获取了父类的结构以后，可以对父类中同名的方法进行“重构”）方法的返回值，方法名，形参列表形同；权限修饰符不小于父类的同名方法；子类方法的异常类型不大于父类的；
两个方法要同为static或同为非static。

可变个数形参

格式：对于方法的形参： 数据类型 … 形参名
可变个数的形参的方法与同名的方法之间构成重载
可变个数的形参在调用时，个数从0开始，到无穷多个都可以。
使用可变多个形参的方法与方法的形参使用数组是一致的。
若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。
在一个方法中，最多声明一个可变个数的形参。

    //可变个数的形参的方法,与数组不是重载他们是一样的，重名后编译器报错
    public void sayHello(String... args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i] + "$");
        }
    }
	
    public void sayHello1(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
	

方法的参数传递（重点、难点）

形参：方法声明时，方法小括号内的参数
实参：调用方法时，实际传入的参数的值

规则：java中的参数传递机制：值传递机制

• 形参是基本数据类型的：将实参的值传递给形参的基本数据类型的变量
• 形参是引用数据类型的：将实参的引用类型变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用类型变量。

 public static void main(String[] args) {
        int i = 10;
        int j = 5;
        System.out.println("i:" + i + " j:" + j);//i : 10  j : 5
        //交换变量i与j的值
        int temp = i;
        i = j;
        j = temp;
        System.out.println("i:" + i + " j:" + j);//i : 5  j : 10
    }

public class TestArgsTransfer {
    public static void main(String[] args) {
        TestArgsTransfer tt = new TestArgsTransfer();
        int i = 10;
        int j = 5;
        System.out.println("i:" + i + " j:" + j);//i : 10  j : 5

//		//交换变量i与j的值
//		int temp = i;
//		i = j;
//		j = temp;
        tt.swap(i, j);//将i的值传递给m，j的值传递给n

        System.out.println("i:" + i + " j:" + j);//i : 10  j : 5
    }

    //定义一个方法，交换两个变量的值
    public void swap(int m, int n) {
        int temp = m;
        m = n;
        n = temp;
        System.out.println("m:" + m + " n:" + n);
    }
}

public class TestArgsTransfer1 {
        public static void main(String[] args) {
            TestArgsTransfer1 tt = new TestArgsTransfer1();
            DataSwap ds = new DataSwap();
            System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);

            tt.swap(ds);
            System.out.println(ds);

            System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);

        }

        //交换元素的值
        public void swap(DataSwap d) {
            int temp = d.i;
            d.i = d.j;
            d.j = temp;
            System.out.println(d);//打印引用变量d的值
        }
    }

    class DataSwap {
        int i = 10;
        int j = 5;
    }

封装

目的：为了维护程序安全稳定性，保护底层数据；

行为：一切为了维护程序的安全稳定性，保护底层数据的行为，都称之为封装。

具体体现：

• 私有属性，公有方法
• 私有构造，静态方法返回类对象
• 内部类：并列内部类包含内部类

访问权限修饰符

注意：

• 对于class的权限修饰只可以用public和default(缺省)。
• public类可以在任意地方被访问。
• default类只可以被同一个包内部的类访问。

构造方法

构造器的作用：

• 创建对象

String str = new String("构造方法为属性赋值")

• 给创建的对象的属性赋值

public Student() {
        name = "为name赋值";
    }

构造器的机制：

• 设计类时，若不显式声明类的构造器的话，程序会默认提供一个空参的构造器. 一旦显式的定义类的构造器，那么默认的构造器就不再提供。
• 如何声明类的构造器。格式：权限修饰符 类名(形参){ }
• 类的多个构造器之间构成重载

类对象的属性赋值的先后顺序：

1. 属性的默认初始化 private String name;
2. 属性的显式初始化 private String name = “呵呵”;
3. 通过构造器给属性初始化
4. 通过"对象.方法"的方式给属性赋值

编译器自动生成的构造方法

	public student (String name){
	    this.name = name;
	}

理解：this.name指的是student中的属性name，然后将参数name赋值于属性name.

日记

临沂出差七日游，我要走了，欠我一顿酒的兄弟，还有那位欠我饭的小姐姐。
前段时间在耳边有人说临沂很穷，我并没有感觉到穷因为菏泽比临沂更穷！你有没有能力在你认为很穷的地方，凭借自己的实力毫不费力买房买车并结婚生子赡养父母吗，如果没有你不觉得可笑吗？

2018-11-04 你坚持巩固的第五天