Java面向对象学习笔记

面向冰箱的概念

面向过程：

(1)      打开冰箱

(2)      存储冰箱

(3)      关闭冰箱

面向过程主要是强调过程，过程就是动作，动作就是功能。函数，我们之前学的编程就是面向过程。C语言就是面向过程的语言。

面向对象强调的是对象，只要找到这个对象，并且它具备所需功能，我们就可以指挥对象去做事情。

面向对象的语言：JAVA,C++,C#

面向对象的特点：

(1)      更符合人们的思考习惯的思想

(2)      将复杂的问题简单化

(3)      将面向过程的执行者转换成了指挥者

举例：

1组装电脑，找一个懂行的人去做。

2.去餐厅吃饭，对象有服务员（点菜的功能）和厨师（做菜的功能）

面向过程没有被淘汰，只是被封装在某个对象的身上，我们只要找到这个对象，他就具备这样的功能。

3.找对象

以后我们做事情的时候，为了提高效率，先找到解决我们这个问题的对象。

4.冒泡排序

5.面试的时候：你是怎么理解面向对象的？

(1)      面向对象的特点：1,2,3

(2)      举例：面试官也在用面向对象的思想来思考问题(一个项目从前期的需要分析，设计，开发，测试，您一个人是可以完成的，但是这样会效率很低，所以你找一个具备这些功能的对象，来指挥对象完成这些事情)。

 

完成一件事情：

分析当中存在的对象有哪些，不关注问题中所涉及的动作有哪些。

解决问题：尽量找具备这个功能的对象来完成。如果没有这样的对象，我们就创建有这项功能的对象，不断地维护对象与对象之间的关系。

这样做可以简化开发，并提高复用性。

 

         怎么确定需要哪些对象？

         举例：人开门

(1)      名词体现法。

(2)      那个对象最清楚这个动作，就把方法定义在该对象的身上

         面向过程：功能都封装在函数中

         面向对象：功能都封装在对象中，对象之间可以相互调用

 

         面向对象的三个基本特征：

1.      封装

2.      继承

3.      多态

 

面向对象的开发，设计，特征：

开发的过程，其实就是在不断的创建对象，使用对象，指挥对象做事情。

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

类和对象的关系

用java语言描述现实世界中的事物，是通过类的形式来体现的。

怎么描述？对于事物的描述只关注两方面1.属性，2.行为

         什么是类？

         类是对事物的描述、

         什么是对象？

         对象就是该类事物实实在在存在的个体。在Java中用new 关键字来创建对象的。

 

         定义类其实就是在定义类中的成员（成员变量-属性；成员方法-行为）。

成员：事物的组成部分。

成员变量：定义在类中，它的作用域最大，在整个类中都有效。

局部变量：定义在方法中或者代码块中。它的作用域：它所在的方法或者代码块中有效。

class Car{
	int num;
	String color;
	void run(){
		System.out.print(num+"......"+color);
	}
}
public class Test {

	public static void main(String[] args) {
		Car c = new Car();//用new关键字来创建对象的，C是一个类类型的引用变量，指向该类型的一个变量
		c.num = 4;
		c.color = "红色";//调用一个对象的内容用 对象。成员
		c.run();
	}

对象在内存中的存放

public static void main(String[] args) {
		Car c1 = new Car();//用new关键字来创建对象的，C是一个类类型的引用变量，指向该类型的一个变量
		Car c2 =new Car();
		c1.num = 10;
		c2.color = "red";
		c1.run();
		c1 = null;
		c1.num = 9;
		c1.run();
	}

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

1.  成员变量：定义在类中，它的作用域最大，在整个类都有效

2.  局部变量：是定义在方法中或者代码块中，它的作用域：它所在的方法或者代码块。

3.  成员变量是存在对内存中的对象中；局部变量存在在栈内崔中的方法中。

4.  成员变量是随着对象的创建而存在的，随着对象的消失而消失。局部变量是随着所属区域的执行而存在的，随着所属区域的结束而释放。

5.  成员变量是有默认的初始化的值；局部变量没有默认的初始化值。

1.4成员变量与局部变量

class Car{
	int num;
	String color;
	void run(){//方法是在栈中运行
		int sum = 10;//这个num是在栈内存中重新申请了一块地址
		System.out.print(num+"......"+color);//num的值为10
	}
}
public class Test {

	public static void main(String[] args) {
		Car c1 = new Car();//用new关键字来创建对象的，C是一个类类型的引用变量，指向该类型的一个变量
		c1.num = 18;
		c1.run();
	}

}

 class Care{
	int num;
	String color;
	
	public void show(Care c) {
		c.num = 4;
		c.color = "red";	
	}		
	void run() {
		System.out.print(num+"......"+color);
		}
}
public class Test1 {

	public static void main(String[] args) {
		Care c1 = new Care();//用new关键字来创建对象的，C是一个类类型的引用变量，指向该类型的一个变量
		c1.show(c1);
		c1.run();
	}

}

匿名对象

/**

        * 匿名对象：没有名字的对象

        *c.run();

        *

        *new Car();//没有的名字对象

        *new Car().run();

        *1.当对象对方法进行一次调用的时候，就可以简化成匿名对象。

        *2.匿名对象可以作为实际参数来传递

        */

封装

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

好处：提高安全性；将变化隔离；便于使用；提高重用性；

封装原则：

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

把属性都隐藏起来，提供公共的方法对其进行访问；。

package C101_封装;

class Preson {
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age > 0 && age < 130){
			this.age = age;
		}else{
			System.out.print("年龄错误");
		}
	}
	private int age;//private 是权限修饰符  ，私有，只能在本类中被访问
	
	public void updateAge(int a){
		if(a > 0 && a < 130){
			age = a;
		}else{
			System.out.print("不合法的年龄");
		}
	}
	void speak(){
		System.out.print(name+"..."+age);
	}
}
public class TestPreson{
	public static void main(String[] args) {
		Preson p = new Preson();
		p.setName("小明");
		p.setAge(18);
		System.out.print(p.getName()+"的年龄是"+p.getAge());
	}

}

封装的步骤：

1.  修改属性的可见性：设为privaye，防止错误数据的修改；

2.  创建公有的get/set方法，用于属性的读写；

3.  在get/set方法中加入属性控制语句，对属性的合法性进行判断；

package C101_封装宠物;

class Dod {
	private String name;
	private String sex;
	private int health;
	private int love;
	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 getHealth() {
		return health;
	}
	public void setHealth(int health) {
		if (health > 0 && health < 100) {
			this.health = health;
		} else {
			System.out.println("健康值应该在0-100之间，默认值为60");
			this.health = 60;
		}
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		if (love > 0 && love < 100) {
			this.love = love;
		} else {
			System.out.println("亲密度应该在0-100之间，默认值为60");
			this.love = 60;
		}
	}
	public void speak() {
		System.out.println("我的姓名是" + this.getName() + "，健康值是"
				+ this.getHealth() + "，和主人的亲密程度是" + this.getLove() + "，我的性别是"
				+ this.getSex());
	}
}

Private

是一个权限修饰符。

用于修饰方法（成员变量和成员函数）

被私有化的成员只有在本类中有效。

 

常用之一：

将成员变量私有化，对外提供get/set方法

方法对其进行访问，提高数据访问的安全性

package C101_构造方法;

public class TestPerson {
	/*
	 * 构造方法：名称和类名相同，是创建对象是调用的方法。
	 *  作用：可以给对象进行初始化 创建对象是都必须通过构造函数来初始化
	 * 
	 * 一个类中如果没有定义构造方法，那么该类中就会有一个默认的空参数的构造方法。
	 * 如果一个类中定义了构造函数，那么类中的默认构造函数就没有了。
	 * 
	 * 一般函数和构造函数有什么区别？
	 * 构造函数：当对象创建时就会调用与之对应的构造函数，对对象进行初始化。
	 * 一般函数：对象创建后，需要函数功能时才被调用。
	 * 
	 * 构造函数：对象创建时只被调用一次。
	 * 一般函数：对象创建后可以被调用多次。
	 * 
	 * 什么时候定义构造函数呢？
	 * 在描述事物时，该事物一存在就具备一些内容，这些内容都定义在构造函数中。
	 * 构造函数可以有多个，用于对不同的对象进行针对性的初始化。
	 * 多个构造函数在类中是以重载的形式来体现的。	
	 *  
	 *  细节：
	 *  1.一般函数不能直接调用构造函数。
	 *  2.构造函数如果前面加了void就变成了一般函数。
	 *  3.构造函数中是有return语句的。
	 *  4.构造函数如果完成了set功能，set方法还是需要的。
	 *  */
	public static void main(String[] args) {
		Person p = new Person();
		p.speak();
	}

}

this关键字

package C101_this关键字;

/*
 * 当成员变量跟局部变量重名时可以用this来区分
 * this代表对象，代表哪个对象？当前对象。
 * 什么叫当前对象，this就是所在方法所属对象的引用
 * 简单的说哪个对象调用了this所在的方法，this就代表哪个对象。
 * 
 * this只能在方法内部使用，表示调用方法的那个对象的引用。
 * 在方法内部调用同一个类的另一个方法就不必使用this，直接调用就好了，当前方法中
 * 的引用会自动应用到同一类中的其他方法
 * 
 * 当要返回当前方法的引用是常用return this
 * 
 * 在构造器中调用构造器用this（），它只能定义在构造函数的第一行，因为初始化动作要优先。
 */
class Persons {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	void speak(){
		System.out.println(name);
	}
}
public class PersonDemo{
	public static void main(String[] arge){
		Persons p = new Persons();
		Persons p1 = new Persons();
		p.setName("小强");
		p1.setName("张三");
		p.speak();
		p1.speak();
	}
}

static关键字

package C101_static关键字;
/*
 * 1.static修饰符，修饰成员变量和成员函数，被对象共享。
 * 2.共享数据出现在对象之前，没有对象是可以被类名调用。
 * 
 * static特点:
 * 1.是一种修饰符，用来修饰成员。
 * 2.修饰的成员被所有的对象所共享。
 * 3.static优先于对象存在，因为static的成员随着类的加载而加载，随着类的消失而消失。
 * 4.static修饰的成员多了一种调用方法，可以直接被类名调用。(类名.静态成员)
 * 5.static修饰的是共享数据，对象中存储的是特有数据。
 * 
 * 成员变量和静态变量的区别：
 * 1.两个变量的生命周期不同：
 *   成员变量随着对象的创建而存在，对着对象的回收而释放。
 *   静态变量随着类的加载而加载，随着类的消失而消失。
 * 2.调用方式不同：
 *   成员变量只能被对象调用。
 *   静态变量可以被类名和对象调用。
 * 3.别名不同：
 *   成员变量也称为实例变量。
 * 	   静态变量也被称为类变量。
 * 4.存储位置不同：
 * 	   成员变量存储在堆内存的对象中。
 *   静态变量存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。
 *   
 * 静态成员在使用中的细节：
 * 1.静态方法只能访问静态成员。非静态方法既可以访问静态成员又可以访问非静态成员。
 * 2.静态方法中不能使用this关键字或者super关键字。
 * 3.主函数就是静态方法。
 */
class Person{
	private String name;
	static String country = "CN";
	
	public void show(){
		System.out.print(country+"..."+name);
	}
}
public class TestPerson {

	public static void main(String[] args) {
		Person p = new Person();
		System.out.println(p.country);
		System.out.println(Person.country);
	}

}