黑马程序员——面向对象（一）

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

面向对象就是将功能封装进对向，强调具备了功能的对象，面向对象是基于面向过程的。

面向对象的三个特征：封装、继承、多态。

类和对对象的关系：类是对现实事物的描述；对象是这类事物实实在在的个体。

属性对应类中的变量，行为对应类中的方法。

例如：一个汽车类

class Car{
		//描述汽车衍颜色
		String color = "red";
		//描述轮胎书
		int num = 4;
		//可以开走的功能
		void run(){
			System.out.println(color+num);
		}
	}

class CarDome{
		public void getCar() {
			//生产一个实体并放在一个类类型变量Car中
			Car car = new Car();
			//调用汽车可以开的方法 
			car.run();
		}
	}

类中的成员变量和局部变量

作用范围：成员变量作用于整个类中；局部变量作用于函数中或者语句中。例如Car类中的color和unm就是成员变量。

在内存中的位置：成员变量在堆内存中，因为对象的存在，因为对象的存在才在内存中存在。

                               局部变量在存在于栈内存中。

封装

封装是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。能将变化隔离，便于使用，同时提高了安全性和使用性。

匿名对象：  是对象的简化形式，一般使用于对对象方法仅进行一次调用时和对象作为参数进行传递时。

 对对象方法仅进行一次调用时例如:

new Car.num = 5;

new Car.run()

上述同时产生了两个对象，而第一个实例一旦运行完就成垃圾被回收了。

对象作为参数进行传递例如：

setCar(new Car());
public static void setCar(Car c) {
		c.color = "black";
		c.num = 3;
		c.run();
	}

封装一个Person类，将Person的name属性私有化，并提供name的set和get方法。

class Person {
	private String name;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	void speak(){
		System.out.println("name="+name);
	}
}
class PersonDome{
	public static void  main(String[] args) {
		Person person = new Person();
		person.setName("SSSS");
		person.speak();
	}
}

封装的原则：1、把不需要对外提供的类容隐藏起来。

                         2、把属性都隐藏，提供公共方法对其访问。
构造函数：给对象进行初始化

当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数，当在类中自定义了构造函数， 默认构造函数就没有了。

class Person {
	private String name;
	private int age;
	
	//有参构造函数
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//无参构造函数
	public Person() {
	}
}

 构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给对象添加具备的功能。

一个对象建立，构造函数只运行一次；而一般方法可以被该对象调用多次。

***构造代码段****

作用：给对象进行初始化；对象一建立就执行，而且优先于构造函数执行。

构造代码块是给所有对象进行初统一始化，而构造函数是给对应的对象初始化。

class Person {
	private String name;
	private int age;
	{
		System.out.println("##########"); //这就是构造代码块
	}
	//有参构造函数
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//无参构造函数
	public Person() {
	}

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

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

this关键字

class Person {
	private String name;
	private int age;
	
	//有参构造函数
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//有参构造函数
	public Person(int age) {
		this.age = age;
	}
	//无参构造函数
	public Person() {
	}
	public boolean  compareAge(Person person) {
		return this.age==person.age; //this关键字代表所在函数所属对象的引用。（那个对象调用，就代表那个对象）
	}
}
class PersonDome{
	public static void  main(String[] args) {
		Person person1 = new Person(20);
		Person person2 = new Person(25);
		person2.compareAge(person1);
		
	}
}

this关键字代表所在函数所属对象的引用。（那个对象调用，就代表那个对象）

当定义类中功能时，该函数内部要用到电泳该函数的对象时，只是就用this来表达这个对象。

Static关键字（静态）

Static关键字用于修饰成员（成员变量和成员属性）；

被修饰的成员具备以下特点：1、随着类的加载而加载。

                                                    2、优先于对象存在；

                                                    3、被所有对象所共享；

                                                    4、可以直接被调用；

public static void main(String[] args) {
		Person.show();  //静态方法的直接调用
		System.out.println(Person.country);  //调用静态的成员属性
	}
	public static class Person{
		String name;
		static String country = "china";   //静态关键字
		//定义一个静态方法
		public static void show() {
			System.out.println(country);
		}
	}

使用注意：静态方法只能访问静态成员；

                    静态方法中部可以写this、super关键字；

                    主函数是静态的

什么时候使用静态：

当对象中出现共享数据时，使用静态变量；对象中的特有数据要定义与非静态 存在于堆内存中。 

当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

public static void main(String[] args) {
		Person.show();  //静态方法的直接调用
	}
	public static class Person{
		String name;
		//该功能内部没有访问到非静态数据，所以定义为静态的
		public static void show() {
			System.out.println("hello word!!!");
		}
	}

静态的使用（工具方法）

public static void main(String[] args) {
		int[] arr = { 3, 2, 6, 5, 4, 78 };
		System.out.println(util.getMax(arr)); // 直接调用静态方法并打印返回值
	}

	public static class util {
		// 定义一个静态的工具方法，该方法接受一个数组，返回数组的最大值
		public static int getMax(int[] arr) {
			int max = 0;
			for (int i = 0; i < arr.length; i++) {
				if (arr[i] > arr[max]) {
					max = i;
				}
			}
			return arr[max];

		}

	}

main函数（主函数）

主函数是一个特殊的函数。作为程序的入口，可以被jvm调用。

//public：代表函数访问权限是最大的
	//static：待变函数随着类的加载就存在了
	//void：主函数没有返回值
	//main：一个特殊单词，可以被jvm识别
	//(String[] args)：函数参数，参数类型是数组，该数组中的元素是字符串。
	//主函数是固定格式;
	public static void main(String[] args) {
		System.out.println("hello word!");
	}

静态代码块

静态代码 随着类的加载而执行，并且只执行一次；用于给类进行初始化。

class chinese {
	static int count = 0;
	static String country = "中国";// static可以省略，不影响效果
	String name;
	int age;
	static void sing() {
		System.out.println("二");// 打印出二；
	}
	void singourcountry() {
		System.out.println(country);
		sing();// 在非静态成员方法中调用静态的成员方法，这是允许的，此成员方法不加static不影响程序
	}
	public chinese() {
		System.out.println(++count);
	} // 类的构造函数
	static {
		count = 5;
		System.out.println("static code");
	}// 静态代码块
}
class test {
	public static void main(String[] args) {
		System.out.println("begin");
		new chinese().singourcountry();// 在新对象调用此方法之前，先运行了静态代码块，然后运行构造函数，最后才运行这个方法。
		new chinese();// 创建对象，只运行了构造函数，但是没有运行静态代码块，因为静态代码块只运行一次
	}
}

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