Java基础----类、变量修饰符、权限修饰符、构造方法、方法重写与重载、单例模式总结----含思维导图

---

一、类

1、四种权限修饰符

  (1) Public：公共的，用public修饰的类可以被任何包以及任何包下的类进行访问。eclipse自动提示：绿色圆
  (2) Protected：受保护的，只能在同一个包中，同一个类以及不同包的子类进行访问。eclipse自动提示：黄色的菱形
  (3) 不写：表示默认（default）的修饰符，只能被同一个包中的类进行访问。eclipse自动提示蓝色的三角形。
  (4) Private：私有，只能在本类中进行访问。eclipse自动提示红色的正方形。
  (5) 图解：
  
  (6) 注意：
    ① 以上的访问控制权限指的是包中的成员且：类本身只有两种访问控制，即public和默认。
    ② 在不同包下的子类中不能用父类对象调用在父类中用protected修饰的属性和方法。
    ③ 在不同包下的子类中需要用子类对象调用在父类中用protected修饰的属性和方法。

2、类的修饰符

  (1) Public ：公共的
  (2) 默认 ：表示默认（default）的修饰符
  (3) abstract(抽象) ：抽象
  (4) final：唯一；
  (5) 注意：
    ① Abstract不能和final同时修饰同一个类。
    ② 一个class文件中可以声明多个类，只能有一个用public修饰的类；即：与class文件名相同的类才能用public修饰，其他类不能用public修饰。

3、变量修饰符

  (1) Public：公共的 。
  (2) Protected：受保护的 。
  (3) 默认：表示默认（default）的修饰符。
  (4) Private：私有，只能在本类中进行访问。
  (5) final：唯一。
    ① 数值不变常量，定义同时应对其进行初始化，不一定，也可以利用构造函数给不同的对象赋不同的值。
    ② 用final修饰的引用类型，只是引用的地址不能改变，即该对象地址锁死，但是对象的属性值是可以进行修改的。
    ③ 用final修饰的基本数据类型是常量，值不能改变。
  (6) static：对所有的实例一致，引用的前缀可使用类名或对象名。
  注意： 用final修饰的属性使用前必须进行赋值。

二、方法

1、方法介绍

  (1) 定义：用来描述该类对象所拥有的某些行为。
  (2) 有返回值的方法：在方法体中必须有return语句，且return的结果类型必须和方法定义的返回类型保持一致，或是其子类用final修饰的属性使用前必须进行赋值操作。
  (3) 参数列表：
    ① 形参：定义方法时在方法名后的（）中声明的参数，该参数对应作用范围时本方法用来接收在调用 该方法时传递的实参。
    ② 实参：在调用方法时给方法传递的参数。即实际参数。
    ③ 可变长参数：一个方法中只能定义一个可变长参数，且该参数必须放在参数列表最后一位。
    

//一个方法中只能定义一个可变长参数，且该参数必须放在参数列表最后一位。
public int sum(String str,int...a){ //两个参数，一个String 类型，一个int类型的可变长参数，变长参数必须放到最后的位置
      int sum = 0;
      return sum;
}

  (4) 注意：
    ① 方法定义后不会自己执行，如果需要执行，一定要进行方法的调用。
    ②方法的定义不能产生嵌套包含关系，即：一个方法中不能再定义其他方法。
    ③ 当一个对象作为参数，传递到方法当中时，实际上传进去的是对象的地址值。

2、方法修饰符

  (1) Public：公共的 。
  (2) Protected：受保护的 。
  (3) 默认：表示默认（default）的修饰符。
  (4) Private：私有 。
  (5) final：不能被重写，可以重载。
  (6) static： 静态方法。
  (7) abstract:抽象方法,只有方法的定义，没有方法体。例如：public static void run();
  注意： 如果一个方法同时用protected和static进行修饰，则该方法可在子类中通过父类.方法、父类对象.方法进行调用。

3、main方法的组成部分介绍

  （1）Public:因为直接被JVM进行调用，所以必须为public。
  （2）Static:因为JVM调用时通过类名.方法名的方式进行调用，所以必须将方法静态绑定到类，必须用static修饰。
  （3）Void:因为main方法没有返回值。
  （4）String[]：它可以接收多个字符串，在java 1.5版本后也可以String…进行替换。

三、构造方法

1、定义

  (1) 方法名字与类名相同，且没有返回值类型，甚至连void都没有。
  (2) 构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法；构造方法的调用是new +构造方法，的形式来调用。

2、构造方法需要满足的条件

  (1) 方法名和类名相同。
  (2)在方法名前面没有返回值类型的声明，连void都没有。
  (3) 在方法中不能使用return语句返回一个值。

3、注意事项

  (1) 构造方法不能被static、final、abstract、native等等修饰
  (2) 使用new创建对象时，系统会自动调用构造方法。
  (3) 构造方法中的参数不需要是成员变量中已经定义过的成员属性：例如下：
    public void test（）；
    int i;
    public test(String a){
    //但是这里面不能传进来String类型的参数，因为类中没有定义String类型的属性。
    }
  (4) 如果类中不写构造方法，系统会提供无参的构造方法 。
  (5) 若该类定义了构造方法，默认的构造方法就会消失 。
  (6) 一般在有参构造方法中都会重写toString()方法。
  (7) 构造方法可以重载,其实含参个数不同的构造方法之间就是重载。

4、构造方法中的单例模式

  (1) 懒汉模式：

package test;

/*
 * 单例设计模式一：懒汉模式
 * 1、私有化构造方法
 * 2、提供public修饰的静态方法用来返回该类的实例
 * 懒汉模式：在调用实例方法的时候才会实例化对象
 */
public class Student {
	private static Student stu;

	private Student() {

	}

	@SuppressWarnings("unused")
	private static Student getStudentInstance() {
		if (stu == null) {
			stu = new Student();
		}
		return stu;
	}
}

  (2) 饿汉模式：

package test;

/*
 * 单例设计模式二：饿汉模式
 * 1、私有化构造方法
 * 2、提供一个静态的类型变量并进行赋值
 * 3、提供public修饰的静态方法用来返回静态类型变量
 * 懒汉模式：在调用实例方法前已经将该类对象进行实例化了
 */
public class Student {
	private static Student stu = new Student();

	private Student() {

	}

	@SuppressWarnings("unused")
	private static Student getStudentInstance() {

		return stu;
	}
}

  (3) 枚举：绝对的单例模式：(此案例为JDK1.5之前的写法，JDK1.5之后，可以通过enum关键字定义枚举类)
      ①：常规类型

package test;

//枚举数据
enum test1 {
	雷妈, 蛋哥
}

public class EnumTest {
	// 定义一周日期
	enum Day {
		SUNDAY, MONDAY, TUESDAY
	}

	public static void main(String[] args) {
		System.out.println(Day.MONDAY);
		System.out.println(test1.雷妈);
	}
}

      ②：枚举支持switch语句

public class EnumTest {
	enum Color {
		RED, YELLOW, GREEN
	}

	public static void main(String[] args) {
		Color cor = Color.RED;
		switch (cor) {
		case RED:
			System.out.println("这是红色。。。");
			break;
		}
		switch (cor) {
		case YELLOW:
			System.out.println("这是黄色。。。");
			break;
		}
	}
}

(4)JDK1.5以后定义枚举类的方法

//使用enum关键字枚举类
public enum Season {
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("鲁班","春天来了"),
    SUMMER("后羿","夏天来了"),
    AUTUMN("伽罗","秋天来了"),
    WINTER("虞姬","冰天来了");
 
    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;
 
    //3.私化类的构造器,并给对象属性赋值
    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
 
    //4.其他需求：根据需要定义
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
}

  （4）单例模式问与答：
    ① 为什么要私有化构造方法？
    答：私有化构造方法的原因是为了保证在其他类中，不能直接通过new 构造方法（）对该类进行实例化。
    ②成员变量为何是static修饰？
    答：因为在静态方法中进行返回，静态方法只能访问静态成员，不能直接访问实例成员。
    ③返回实例类型方法为什么必须是静态方法？
    答：因为构造方法私有化，无法通过构造方法创建对象，没有对象，则不能通过对象.方法进行调用，只能通过类名.方法名调用。

四、方法重写

   （1）定义： 在子类中定义与父类方法名相同的方法，方法的返回值、方法的参数列表以及权限修饰符都相同的方法。
    ① 方法名相同
    ② 方法的参数列表相同（参数类型、参数个数、参数顺序相同与参数名无关）。
    ③方法的返回值不能比父类的返回值更加宽泛，可以是父类返回值的子类。
    ④方法不能比父类方法有着更加严格的访问权限。
    ⑤方法不能比父类方法声明更大更多的异常。
    ⑥父类的静态方法不能被重写。
    ⑦父类中final修饰的方法不能被重写
   （2）验证：@override验证方法是否被重写。
   （3）意义：当父类的方法不能满足子类的需要时，子类可以对方法进行重写，即对行为有不同的实现.
   （4）前提：必须有继承关系，且在子类中进行重写。
   （5）调用：子类重写父类方法后，通过子类对象调用方法调用的是子类自身重写后的方法。如果子类没有重写父类方法，默认调用父类方法。
   （6）隐藏：子类中的某个变量的变量名与它的父类中的某个变量完全一样，则称子类中的这个变量隐藏了父类的同名变量。

五、方法重载

   （1）定义： 在同一个类中定义多个同名的方法，且方法的参数列表不同，与返回值、访问控制权限无关。
   注意： 方法名相同，参数列表不同。

六、方法的调用

1、调用的三种方式

   （1）直接通过方法名进行调用：只能在本类中调用本类的其他方法。在静态方法中不能通过方法名的方式直接调用实例方法，需要通过对象.方法名的方式调用实例方法（非静态方法）。
   （2） 直接通过类名.方法进行调用：所调用的方法必须时静态方法。
   （3）通过对象.方法进行调用。

2、方法的调用时的匹配模式

   （1）方法名匹配。
   （2）参数列表匹配：按照参数类型以及参数个数。

3、方法的值传递

   （1） 如果参数是基本数据类型则调用方法时传递的时具体的值。
   （2） 如果是引用类型，则调用方法是传递的是引用类型对象的地址。
   （3） 实参的传递顺序必须和形参的定义顺序保持一致。
   注意： ：
   （1） 在静态方法中不能通过方法名的方式直接调用实例方法，需要通过对象.方法名的方式调用实例方法。
   （2） 在实例方法中可以直接通过方法名调用本类中的其他方法。（不论是否是静态方法）。
   （3） 在实例方法中调用其他类中的静态方法：通过类名.方法名进行调用，也可以通过其他类的对象.方法名进行调用；但是不推荐这种方式。
   （4）在实例方法中调用其他类的实例方法：只能通过其他类的对象.方法名进行调用。
   （5） 静态方法：可以通过类名.方法名调用，也可以通过对象.方法名调用；而实例方法（非静态方法），只能通过对象.方法名调用。
   （6） 静态方法也不能使用this和super关键字。

七、思维导图