黑马程序员 Java面向对象<一> 基础

---------- android培训、java培训、期待与您交流！ ----------

    在java世界里万物万物皆对象。下面总结一下面向对象思想吧！

一、面向对象概念

    理解面向对象

    1、面向对象:它是相对面向过程而言,面向对象和面向过程都是一种思想

    2、面向过程:强调的是功能

    3、面向对象:将功能封装进对象,强调具备了功能的对象

    面向对象特点

    1、将复杂的事情简单化。

    2、面向对象将以前的过程中的执行者，变成了指挥者。

    3、面向对象这种思想是符合现在人们思考习惯的一种思想。

   

    过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。

       

    面向对象和面向过程图

    面向过程思想: 开启、重启、关闭都动作,他们之间没什么联系.都是单独完成一些功能。

    面向对象思想: 开启、重启、关闭都是电脑所具备的功能,由它来完成这些动作他们是一个整体。

    面向对象有三大特征：封装，继承，多态 

    以后的开发过程：其实就是找对象用。没有对象，就创建一个对象,使用对象,指挥对象做事情。

    设计的过程：其实就是在管理和维护对象之间的关系。

    

二、类与对象的关系  

   类与对象

   类：就是对现实生活中事物的描述。

   对象：就是这类事物，实实在在存在的个体。

   想要描述：提取对象中共性内容。对具体的抽象。 

   映射到Java中描述就是class定义的类。具体对象就是对应Java在堆内存中用new建立实体。

   类定义

    定义：就是在描述事物，就是在定义属性和方法，属性和行为共同成为类中的成员（成员变量和成员方法）。

   java中用类class类描述事物也是如此

      属性:对应类中的成员变量

      行为:对应类中成员函数

//描述汽车类
class Car{
	//定义两成员变量
	String color = "黑色";//描述汽车的颜色 
	int num = 4;	      //描述汽车的轮胎数
	//描述车的运行
	public void run(){
		System.out.println("颜色="+ color +"……轮胎="+ num);
	

	}
}
public class Temp
{
	public static void main(String[] args){
		//生成汽车，在Java中通过new操作符来完成 
		//其实就是在堆内存产生一个实体 
   	Car c = new Car();//建立对象
		c.run(); //调用汽车运行的方法
	
	}

}

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

     1、作用地方

        成员变量:定义在类中,作用于整个类中

        局部变量:定义在函数 语句，局部代码块中，只在所属的大括号区域有效。 

     2、作用时间

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

        局部变量:随着所属区域的执行而存在，随着所属区域的结束而释放

     3、内存中存储位置

        成员变量:存在于堆内存的对象中。

        局部变量:存在于栈内存的方法中。 

    4、初始化

        成员变量:都有默认初始化值。 

        局部变量:没有默认初始化值。

    对象内存结果图

    

     匿名对象

   

/**
 * new Car();匿名对象是对象的简写形式
 * 匿名对象使用场景：
1：当对方法只进行一次调用的时候，可以使用匿名对象。
2：当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。

 */
//描述汽车类
class Car{
	//定义两成员变量
	String color = "黑色";//描述汽车的颜色 
	int num = 4;	      //描述汽车的轮胎数
	//描述车的运行
	public void run(){
		System.out.println("颜色="+ color +"……轮胎="+ num);
	}
}
public class Temp
{
	public static void main(String[] args){
		
		new Car().color="green";//匿名修改对象属性,不过调用匿名对象的属性没有意义。
		//匿名对象调用方法，只调用一次。
		new Car().run();
		changeCar( new Car() );//可以将匿名对象作为实际参数进行传递
	
	}
	//汽车改装厂修改汽车 的属性
	public static void changeCar(Car c){
		//颜色喷成白色
		c.color = "白色";
		//汽车改成 3轮车 哈哈
		c.num = 3;
		c.run();
	}

}

三、封装

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

    封装好处

     1、将变化隔离

     2、便于使用

     3、提高重用性

     4、提高安全性

   封装原则

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

    把属性都隐藏,提公供方法对其访问

   private关键字

      用于修饰成员变量和成员函数

     被修饰的内容在其他类中是不可以被访问的

     注意：私有仅仅是封装的一种体现而已

/**
 * private 私有
 * 将成员变量私有化,对外提供对应的set,get方法对其访问。提高数据安全性
 */
class Person{
	private String name;
	private int age;
	
	public void setName(String name){
		this.name = name;
	}
    public String getName(){
    	return this.name;
    }
	
	public void setAge(int age){
		//加入判断，使程序更为符合逻辑 
		if(age>=0 && age<=150)
			this.age = age;
		else 
			System.out.println("不合法数据");
	}
	//对外提供公共的获取方法 
	
	public int getAge(){
		return this.age;
	}
	
	public void speak(){
		System.out.println("name="+name+" age="+age);
	}
	

}
public class Temp
{
	public static void main(String[] args){
		Person p = new Person();
		p.setName("赵麻子");
	      //p.setAge(-1);数据不合法
		p.setAge(24);
	    p.speak();
	}

}

四、构造函数

    构造函数:构建创造对象时调用的函数

    构造函数特点

     1、函数名与类名相同

     2、不要定义返回值类型

     3、不可写return语句

    构造函数作用

      1、给对象进行初始

         创建对象都必须要通过构造函数初始化

      2、一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

         如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

    注意

     1、默认构造函数的特点

     2、多个构造函数以重载形式存在

 

class Person{
	String name;
	int age;
	Person(){}
	Person(String name,int age){
		this.name = name;
		this.age = age;

	}

	public void speak(){
		System.out.println("name="+name+" age="+age);
	}

}
public class Temp
{
	public static void main(String[] args){
		Person p = new Person();
		p.speak();//打印默认初始化
		Person p2 = new Person("王二麻子",20);//调用构造函数创建对象
		p2.speak();
		
	}

}

   一般函数和构造函数区别

    构造函数：对象创建时，就会调用与之对应的构造函数，给对象进行默认初始化。

   一般函数：对象创建后，需要函数功能时才调用。(函数只有被调用才执行) 

   构造函数：对象创建时，只调用一次。 

   一般函数：对象创建后，可以被调用多次。

   

   什么时候定义构造函数呢 

    在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数中。 

    构造函数可以有多个，用于对不同的对象进行针对性的初始化。 

五、构造代码块

    构造函数作用：给所有对象进行初始化。  

   对象一建立就运行，而且优先于构造函数执行

   和构造函数的区别： 

   构造代码块是给所有对象进行统一初始化。 

   而构造函数是给对应的对象进行初始化。 

   构造代码块中定义的是不同对象共性的初始化内容。 

   总结：构造代码块和构造函数共性的地方就是当对象创建时，就给对象进行初始化一次。 

        

六、this关键字  

   this:代表对象。就是所在函数所属对象的引用。

   this到底代表什么呢？

      哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用。

   开发时，什么时候使用this呢？

      在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。

   this 还可以用于构造函数间的调用。

     调用格式：this(实际参数)；

   this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；

   this对象后面跟上() 调用的是本类中的对应参数的构造函数。

     注意

       用this调用构造函数，必须定义在构造函数的第一行。

        因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。

        构造函数间调用只能用this

        this调用构造函数一定要留一个构造方法作为出口。

    作用:用于修饰成员

七、static关键字

   被修饰后的成员具备以下特点

    1、随着类的加载而加载

    2、优先于对象存在因为,static的成员随着类的加载就已经存在了

    3、被所有对象所共享

    4、被修饰的成员多了一种调用方式，可以直接被类名调用。类名.静态成员

   使用注意

    1、静态方法只能访问静态成员

    2、静态方法中不可以写this,super关键字

    3、主函数是静态的,说以主函数调用的方法也必须是静态

   成员变量和静态变量区别

    1、两个变量的生命周期不同

        成员变量:随着对象的创建而存在，随着对象的被回收而释放。

        静态变量:随着类的加载而存在，随着类的消失而消失

    2、调用方式不同

        成员变量:只能被对象调用

        静态变量:可以被对象调用,还可以被类名.调用

    3、别名不同

        成员变量:也称为实例变量 

        静态变量:也称为类变量

    4、数据存储位置不同

        成员变量:存在堆内存的对象中,所以也叫对象的特有数据

        静态变量:数据存在方法储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。  

   什么时候该用static呢

      如果某个内容时所有对象共享的,就用静态修饰

   什么时候用静态成员函数呢

       要从两方面下手：因为静态修饰的内容有成员变量和函数

      什么时候定义静态变量呢

       当对象中出现可共享数据时,该数据被静态修饰

       对象中的特有数据要定义成非静态存在于堆内存中

      什么时候定义静态函数呢

        当功能内部没有访问到非静态数据,或者对象的特有数据

        那么该功能可以定义成静态的

   静态有利有弊

    好处:对对象共享的数据进行单独空间的存储,没有必要每个对象都存一份可以被类名.调用

    弊端:生命周期过长,访问出现局限性(静态虽好,只能访问静态)

   主函数是静态的 

/**
 * public static void main(String[] args)
 * 主函数特殊之处： 
1  格式是固定的。（除了args这个数组名字可以变，其他不行） 

2  被Jvm所识别和调用。 

public：因为权限必须是最大的。 

static：不需要对象的，直接用主函数所属类名调用即可。 

void：主函数没有具体的返回值。（因为返一个值给虚拟机，虚拟机也害怕啊！是不是虚拟机没有内存存放） 

main：函数名，不是关键字，只是一个Jvm识别的固定的名字。 

String[] args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。
 */

public class Temp
{
	public static void main(String[] args){

		System.out.println(args);//打印[Ljava.lang.String;@19836ed，大家的内存地址值都是不一样的。
	}

}