[Java知识库]4600字的封装、继承，多态笔记（推荐收藏）

1、对象和封装

1.1、构造方法

语法：

[ 访问修饰符 ] 方法名 ( [ 参数列表 ] ){
//……省略方法体的代码
}

• 构造方法的名称必须和类名相同，但是没有返回值类型。在构造方法的定义中参数列表是可选的，因此可以定义无参构造方法，也可以定义带参构造方法。

• 在java中，每一个类都默认自带了一个构造方法叫做缺省构造器，如有没有创建，则系统会自动创建一个默认的构造方法，默认构造方法是没有参数的，而且在方法体中没有代码。（无参构造器）

注意： 当我们创建了构造方法之后，Java自带的无参构造方法就会消失，需要我们自己写出来

1.2、this

this 的三种用法：

1、使用 this 关键字调用成员变量，解决成员变量和局部变量的同名冲突

	public Strive(String name){
		this.name = name;  //成员变量和局部变量同名，必须使用 this 关键字
	}

2、使用 this 关键字调用成员方法

	public Strive(String name){
		this.name = name;
		this.print(); // 调用成员方法
	}

3.使用 this 关键字调用已定义的构造方法
在以下代码中定义了 Strive 类，并定义了两个带参构造方法

	public void Strive(){
        String name;
        String sex;
        int age;
        String dept;
        public Strive(String name, String sex){
            this.name = name;
            this.sex = sex;
        }
        public Strive(String name, String sex, int age, String dept){
            this(name,sex);	//调用已定义的构造方法（调用上面那个构造方法）
            this.age = age;
            this.dept = dept;
        }
    }

以上使用 this 关键字调用构造方法，并传入局部变量 name 和 sex 作为参数，执行时，首先执行 Strive(String name,String sex) 构造方法，完成对 name 属性和 sex 属性的赋值，然后执行后面的语句实现对 age 属性和 dept 属性的赋值。

1.3、方法重载

1.3.1、方法重载的定义

方法重载指的是同一个类包含两个或两个以上的方法，它们的方法名相同，方法参数个数不同，
方法参数类型不同。成员方法和构造方法都可以进行重载

例如：

	System.out.println("good");
	System.out.println(true);
	System.out.println(100);

这里的方法重载使用的是方法参数类型不同

1.3.2、方法重载的特点

方法重载判断的依据如下：

• 必须在同一个类中
• 方法名相同
• 参数列表 （方法参数的个数或参数类型） 不同

注意： 方法的返回值和方法的访问修饰符不能作为判断方法之间是否构成重载的依据

1.3.3、方法重载的使用和优点

 	public int Strive(int a,int b){
        return a+b;
    }
    public double Strive(double a,double b){
        return a+b;
    }
    public String Strive(String s1,String s2){
        return s1+s2;
    }

    public static void main(String[] args) {
        Adder adder = new Adder();
        int a = 6,b = 8;
        System.out.println(adder.Strive(a,b));
        double c = 9 , d = 10.9;
        System.out.println(adder.Strive(c,d));
        String s1 = "Hello",s2 = "World";
        System.out.println(adder.Strive(s1,s2));
    }

• 由以上代码可见，方法重载是对原有方法的一种升级，可以根据参数的不同，采用不同的实现方法，而且不需要编写多个名称，简化了类调用方法的代码

1.3、使用封装重构类的属性和方法

1.3.1、封装的概念

封装是面向对象的三大特性之一，就算将类的状态信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法实现对隐藏信息的操作和访问。

封装反映了事物的相对独立性，有效避免了外部错误对此对象的影响，并且能够给用户由于大意产生的错误操作起到预防作用

• 好处： 封装的好处在于隐藏类的细节，让用户只能通过开发人员规定的方法访问数据，可以方便地加入访问修饰符来限制不合理操作

1.3.2、封装的步骤

实现封装的步骤如下：

1、修改属性的可见性来限制对属性的访问
2、 为每个属性创建一对赋值（setter）方法和取值（getter）方法，用户对这些属性的存取
3、在赋值方法中，可以加入对属性的存取控制语句

1、修改属性的可见性：

使用 private 访问修饰符修饰，private 修饰的属性和方法只能在定义它的类的内部被访问

2、创建赋值和取值方法：

get 方法取值、 set 方法存值
get 方法读、 set 方法改
以上看哪一个能理解，意思一致，代码如下：

	private String name;  // 私有属性
	public void getName(){ //get方法 读
		return name;
	}
	public void setName(String name){ //set 改
		this.name = name;
	}

3、加入对属性的存取控制语句

为了限制不合理赋值，除了设置属性的私有性，还可以在赋值方法中加入对属性的存取控制语句。
假如性别：只有男，女，年龄：0~100 ;代码如下：

	private grnder; // 性别
	private int age; // 年龄
	// 省略get 方法
	public void setAge(int age){	//控制年龄
		 if(age < 0 || age > 150){
            System.out.println("输入的年龄为:"+age+",该年龄不合法！");
            return;
        }else{
            this.age = age;
        }
	}
	 public void setGender(String gender) {	//控制性别
        if(gender.equals("男") || gender.equals("女")){
            this.gender = gender;
        }else{
            System.out.println("*** 性别不合法 ！***");
        }
    }

1.4、类和类成员的访问控制

1、类和访问修饰符

省略访问修饰符，就算默认修饰符

2、类成员的访问修饰符

1.5、static 关键字

static 关键字可以修饰类的属性，方法和代码块。使用 static 修饰的属性和方法不再属于具体的某个对象，而属性它所在的类

使用 static 修饰的 属性或方法可以使用 “ 类名 . ” 的方式调用，不需要再消耗资源反复创建对象

使用 static 修饰的方法属于 静态方法，使用类名调用，static 修饰的变量属于静态变量，类加载的时候加载进方法区

1.5.1、用 static 关键字修饰属性和代码块

如下静态代码块：

	static{
		System.out.println("HelloWorld");
	}

static 修饰的是类加载的时候执行，创建对象的时候执行，创建对象的时候应先执行 static静态代码块里面的内容

注意：

• 有多个静态代码块的时候，按照静态代码块的前后顺序执行
• 在方法里不可以定义 static 变量，也就是静态变量不能是局部变量
• 在静态方法中不能直接访问实例变量和实例方法
• 在实例方法中可以直接调用类中定义的静态变量和静态方法

    /**
    *动物父类
    */
	public class Animal {
    public void cry(){
        System.out.println("动物叫。。。。");
    }
}
	/**
	*	继承了动物类的小猫类也有 cry() 方法（子类）
	*/
public class Cat extends Animal {
   // 有父类的方法与属性 
}

	Strive strive1 = new s1();

	Strive strive1 = (Strive)s1;

	 if(Strive instanceof s1){  // 类型判断
            Strive strive1 = (Strive)s1;
        }else{
        	System.out.println("Strive与s1没有关系");
        }