Java基础语法（四）-----面向对象（1）基础概念、封装

 一、  面向对象思想

   1、概述

   面向过程我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。

      那么什么是面向过程开发呢?面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

      面向过程的代表性语言就是C语言。

   2、面向对象

      当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。接下来我们看看面向对象到底是什么?

    * 面向对象思想：面向对象是基于过程的编程思想

    * 面向对象开发：就是不断地创建对象、调用对象、指挥对象解决问题

    * 面向对象设计：其实就是管理和维护对象之间的关系

    * 面向对象的特征：封装、继承、多态

二、 类与对象及其使用

 1、 类与对象的关系

   * 类：是一组相关的属性和行为的集合

   * 对象：是该类事物的具体体现

    例如：创建一个学生类（可以是姓名、年龄、班级等属性的集合），而定义一个学生类的对象，可以是班长，班长是学生的具体体现。

     类与对象的关系也可如图所示：有一个水果类，梨、苹果、桃子都是该类的一个具体对象。

2、 类的定义

    定义类其实就是定义类的成员，即成员变量和成员方法。

    具体案例：定义一个学生类Student

      * 定义一个Student类（分析该类应具有的属性、功能）

      * 创建对象：类名 对象名 = new 类名（）；

      * 使用对象：对象名.成员变量；

                 对象名.成员方法名（参数...）；   

public class Student {
	//成员属性
	String name;//姓名
	int age;//年龄
	//成员方法
	void doHomework(){
		System.out.println("学生每天都要做作业");
	}
}

测试类：

public class Text {

	public static void main(String[] args) {
		//创建对象
		Student stu = new Student();
		//使用对象
		int age = stu.age ;
		String name = stu.name ;
		stu.doHomework();
	}

}

3、 对象的内存图解

    以上面的学生类为例，

 4、 成员变量和局部变量的区别

   * 在类中的位置不同

      成员变量定义在方法外，局部变量定义在方法内

   * 在内存中的存储位置不同

      成员变量存储在堆内存中，局部变量存储在栈内存中

   * 生命周期不同

     成员变量随着对象的加载而加载，随着对象的消失而消失；局部变量随着方法的调用而存在，随着方法的调用完毕而消失

   * 初始值不同

     成员变量有默认的初始值，局部变量没有默认初始化值，必须先经过定义，赋值，才能使用。

 注意：当成员变量和局部变量重名时，我们采取就近原则。

例：Teacher类

public class Teacher {
	public String tname;
	public int tage;

	public void show(String tname){
		//当成员变量和局部变量重名的时候，我们采用的就是就近原则
		System.out.println("第一句打印的是"+tname);
		System.out.println("第二句打印的是"+tname);
		System.out.println("第三句打印的是"+this.tname);
	}
}

//测试类

public class Test {

	public static void main(String[] args) {
		
		Teacher teacher = new Teacher();
		teacher.tname="小明";
		teacher.show("小红");
        }

运行结果：

  5、 形式参数问题（基本数据类型、引用数据类型）

 * 基本数据类型作为形式参数：基本数据类型的数据的改变不会影响实参的值

 * 引用数据类型作为形式参数：其值的改变会直接影响实参的改变

例：

public class Student {
	public String name;
	public String sex;
    public int age;
    
}

public class Text {

	public static void main(String[] args) {
		Student stu = new Student();
		stu.age =18;
		stu.name ="lisi";
		System.out.println(stu.age);
		System.out.println(stu.name);
		//传参
		show(stu);//引用数据类型作为形式参数传递
		show(stu.name);//基本数据类型作为形式参数传递
		System.out.println(stu.age);
		System.out.println(stu.name);
		

	}
	public static void show(Student stu){
		stu.age =20;
	}
	public static void show(String name){
		name="zhangsan";
	}

}

三、匿名对象

  * 匿名对象：就是没有名字的对象，是对象的一种简化表现形式

  *匿名对象的两种使用情况：

      该对象调用方法仅使用一次的时候；

      作为实际参数传递；

   注意：匿名对象每new一次，都是不同的对象

   案例：创建一个Student学生类，测试类如下例题

public class Student {
	public String name;
	public String sex;
    public int age;
    
    public Student getStudent(Student stu,String name,int age){
    	stu.name =name;
    	stu .age =age ;
    	return stu;
    }
    public void show(){
    	System.out.println("这是一个学生类");
    }
}

例1：创建匿名对象

public class Text {

	public static void main(String[] args) {
		new Student();//创建匿名对象1
		new Student();//匿名对象2
		//两次打印对象的地址值不同
		System.out.println(new Student());
		System.out.println(new Student());
		
	}
}

  运行结果：

YinLi.Student@6d06d69c

YinLi.Student@7852e922

例2：匿名对象传参

public class Text {

	public static void main(String[] args) {
		Student stu1=new Student();
		stu1.name ="Jack";
		stu1.age=18;
		stu1=stu1.getStudent(stu1, "Lily", 24);//非匿名对象传参
		System.out.println(stu1.name );
		System.out.println(stu1.age );
		//匿名对象传参
		Student stu2=stu1.getStudent(new Student(), "Bob", 19);
		System.out.println(stu2.name );
		System.out.println(stu2.age );
	}
}

运行结果：

Lily

24

Bob

19

例3：有时只想调用一次成员方法，我们可以使用匿名对象

public class Text {

	public static void main(String[] args) {
		new Student().show();
	}
}

四、封装

  *封装概述：是指隐藏对象的属性和实现细节，仅对外界提供公共的访问方式。

  *好处：

        隐藏实现细节，提供公共的访问方式

        提高了代码的复用性

        提高安全性。    

 * 封装原则：

        将不需要对外提供的内容都隐藏起来。

        把属性隐藏，提供公共方法对其访问。

五、private关键字

    之前，我们都是用public权限修饰符来修饰变量的，通过 对象名.成员变量 这种方式给变量赋值，但是这种赋值方式是不好的，因为这种赋值方式会赋上不合理的数据，如：给人的年龄赋值200，这明显是不合理的，因此，出于数据安全和合理性方面的考虑，我们应该屏蔽掉这种设置成员变量值得方式。就需要权限修饰符private来限定变量的使用，在类中提供一个公共的get和set方法来设置和获取值。

    private关键字，是一种权限修饰符，可以修饰成员变量和成员方法，被private修饰的成员只能在本类中被访问。

     建立一个标准的案例，使用private：

     建立一个Person类，创建对象、赋值，并测试

     

public class Person {
	//来写一个标准的类型
	//1.私有化成员变量
	private String name;
	private int age;
	//提供公共的set get 方法用来设置值，和获取值
	public void setName(String mingzi){
		
		name=mingzi;
		
	}
	public void setAge(int nianling){
		
		age=nianling;
		
	}
	public String getName(){	
		
		return name;
	}
	public int getAge(){
		
		return age;
	}

}

测试类：

public class Test {

	public static void main(String[] args) {
		Person person=new Person();
		person.setName("Bob");
		person.setAge(18);
		
		String name = person.getName();
		int age = person.getAge();
		
		System.out.println(name);
		System.out.println(age);
		
		

	}

}

 

   **   private和public的区别：

  

   1、private可以修饰成员变量、成员方法、内部类，但是只能在本类中被访问，其他类不能直接通过对象名来访问。

   2、public也是权限修饰符，可以修饰类、成员变量、成员方法，被public修饰的可以在其他类中直接通过对象名来访问。

   例：

  

public class Student {
	private String name;
	private String sex;
        private int age;
    
    //get 和 set方法来设置和获取成员变量
        public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void show(){
    	System.out.println("这是一个公有的学生类方法");
    }
        private void showing() {
    	System.out.println("这是一个私有的学生类方法");
    }
}

测试类：

public class Text {

	public static void main(String[] args) {
		Student stu1=new Student();
		stu1.name ="Jack";
		stu1.age=18;

//		System.out.println(stu1.name );
//		System.out.println(stu1.age );
	}
}

说明：通过对象stu1直接在Text类中打点访问Student类中被private修饰的变量name和age编译会报错，如下：

    

同样，也不能直接调用showing()方法。

正确的做法如下：

public class Text {

	public static void main(String[] args) {
		Student stu1=new Student();
		stu1.setName("Bob");
		stu1.setAge(18);
		String name = stu1.getName();
		int age = stu1.getAge();

		System.out.println(name );
    	System.out.println(age );
	}
}

被private修饰的showing方法只能在Student类中被访问。

六、this关键字

    this:是指该类对象的一个引用，可以记为 "谁调用我，我就指代谁"。

    ** 当局部变量和成员变量重名时，可以通过使用this关键字来区分。如下：

public class Animal {
	private String name;
	private int age;
	
	public void setName(String name){  //局部变量：name
		this.name=name;  //this.name中的name是成员变量
		
	}
	
}

  

   ** 谁调用this，this就指代谁

  

public class Animal {
	private String name;
	private int age;
	
	public void setName(String name){
		this.name=name;
	}
	
        public void setAge(int age){
	  	//当局部变量和成员变量重名的时候，我们可以用this 去区分这两个变量
		this.age=age;
	}
	public String getName() {
		return this.name;
	}

	public int getAge() {
		return this.age;
	}	
	public Animal getAnimal(Animal an) {
		//当你看到一个方法的返回值 要一个 类 类型 你得返回一个该类的对象
		an.setName("熊大");
		return this;
	}
	

	
}

测试类：

public class Test {

	public static void main(String[] args) {
		Animal a = new Animal();
		a.setName("猴子");
		
		//this 关键字，代表一个本类的对象（引用）， 谁调用我 我就代表谁
			Animal animal = new Animal();
			Animal animal2 = a.getAnimal(animal);
			System.out.println(animal2.getName());
			System.out.println(animal.getName());
		
	}

}

运行结果：

    说明：Animal animal2 = a.getAnimal(animal);表示对象 a 调用getAnimal()方法，所以 getAnimal()方法中的this返回值指的就是返回对象 a。又将返回的对象 a 赋给对象animal2，因此animal2和对象 a 指的是同一个引用，所以第一次打印结果为“猴子”。   因为传递的参数是引用类型数据（对象animal），且在getAnimal()方法中将其名字改为“熊大”，因此，第二次打印结果为“熊大”。

七、static关键字

    

    static是静态的意思，既可以修饰变量，也可以修饰方法，还可以修饰类。

  ** static关键字的特点：

           所属于类，随着类的加载而加载；

           优先于类存在；

           被类中的所有对象共享；

           可以通过类名直接调用被Static修饰的变量和方法。

 ** 静态的内存图：静态的内容存在于方法区的静态共享区。

  ** static关键字注意事项：

 1、在静态方法中是没有this关键字的。

       因为this指代的是一个对象，而静态方法是先于对象存在的，因此静态方法此时是访问不到还没有创建的对象的.

 2、静态的方法只能访问静态的成员变量或方法。原因同上。

  **  静态变量与成员变量的区别

 1、所属不同

  • 静态变量属于类，所以也称为为类变量

   • 成员变量属于对象，所以也称为实例变量(对象变量)

2、内存中位置不同

  • 静态变量存储于方法区的静态区

  • 成员变量存储于堆内存

3、内存出现时间不同

  • 静态变量随着类的加载而加载，随着类的消失而消失

  • 成员变量随着对象的创建而存在，随着对象的消失而消失

4、调用不同

  • 静态变量可以通过类名调用，也可以通过对象调用

  • 成员变量只能通过对象名调用

    

九、代码块

  

  

    在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，

静态代码块，同步代码块(多线程讲解)。

    •局部代码块

         在方法中出现；限定变量生命周期，及早释放，提高内存利用率。

    •构造代码块

         在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。

   •静态代码块

         在类中方法外出现，加了static修饰；

         用于给类进行初始化，在加载的时候就执行，并且值执行一次。

   注意事项：

       静态代码块先执行：随着类的加载而加载,只执行一次

       构造代码块，优先于构造方法先执行 构造代码块和构造方法是每new一次就会执行一次

 

   例：

    

//学生类
class Student {
	static {
		System.out.println("Student 静态代码块");//3
	}

	{
		System.out.println("Student 构造代码块");//4 6
	}

	public Student() {
		System.out.println("Student 构造方法");//5 7
	}
}

//测试类
class StudentDemo {
	static {
		System.out.println("StudentDemo的静态代码块");//1
	}

	public static void main(String[] args) {
		System.out.println("我是main方法");//2

		Student s1 = new Student();
		Student s2 = new Student();
	}
}

    运行结果：