java小白总结--面向对象

java面向对象的语言
对象:真实存在唯一的事物。
类：实际就是对某种类型事物的共性属性与行为的抽取。
现实生活中；先认识对象，再认识类。
java语言中：先有类，再有对象。

面向对象的计算机语言核心思想： 找适合的对象做适合的事情。
如何找适合的对象：
1：sun已经定义好了很多的类，我们只需要认识这些类，我们就可以通过这些类创建对象使用。
2：自定义类，来创建对象使用。
3：访问对象的属性或者调用对象的功能。

自定义类创建对象的三步骤：

1：自定义类。
格式：
class 类名{
事物的公共属性使用成员变量描述。
事物的公共行为使用函数描述。
}
2：通过类创建对象。
格式：
new 类名();
3：访问(设置)对象的属性或者调用对象的功能。
访问对象属性的格式：
对象，属性名。
设置对象的属性：
对象，属性名=数据。。。。
调用对象的功能：

需求：使用java类描述一个汽车类，汽车具备轮子数、名字、颜色三个属性，还具备跑的功能行为。

package demo;
//车类
class Car{
	//事物的公共属性使用成员变量描述。
	String name;  //名字属性
	String color;  //颜色属性
	int wheel;   //轮子数
	//事物的公共行为使用函数描述。
	public void run() {
		System.out.println(name+"飞起来了");
	}
}
public class day06_面向对象 {
	public static void main(String[] args) {
		//使用了Car类声明一个c变量，c变量指向了一个车对象。
		Car c =new Car();
		//设置车对象的属性值。
		c.name="BMW";
		c.color="白色";
		c.wheel=4;
		//访问车对象的属性值。
		System.out.println("名字："+c.name+"颜色："+c.color+"轮子数："+c.wheel);
		c.run();	
	}
}
/*运行结果：
 名字：BMW颜色：白色轮子数：4
BMW飞起来了
 
 */

需求：使用java描述一个车与修车厂两个事物，车具备的公共属性：轮子数、名字、颜色。还具备跑的功能行为。跑之前要检测轮子是否少于了4个，如果少于了4个，那么就要送到修车厂修理，
修车厂修理之后，车的轮子数要补回来4个，然后车就继续的跑起来了。

package exercise;
import java.util.Arrays;
import java.util.Scanner;

	/*需求：使用java描述一个车与修车厂两个事物，车具备的公共属性：轮子数、名字、颜色。还具备跑的功能行为。跑之前要检测轮子是否少于了4个，如果少于了4个，那么就要送到修车厂修理，
	修车厂修理之后，车的轮子数要补回来4个，然后车就继续的跑起来了。
	
	修车厂：具备公共属性:名字、地址、电话。
	公共的行为：修车。
初学者的经典错误：
	1:不在同一个范围内随意的引用变量。
	   变量在同一个作用域上是可以直接访问的。
	2:如果一个类要访问另外一个类的变量时，
	  就只能通过创建对象进行访问。(仅对于目前正确)
	*/
	class Car{
		//事物的公共属性使用成员变量描述
		String name;
		String color;
		int wheel;
		//事物的公共行为使用函数描述
		public void run() {
			if(wheel>=4) {
				System.out.println(name+"飞快跑起来了");	
			}else {
				System.out.println("快去修车");
			}	
		}
	}
	class CarFactory{
		String name; //名字
		String address;  //地址
		String tel;  //电话
		//修车的公共行为---返回值类型、未知的参数
		public Car repair(Car c) {
			if(c.wheel>=4) {
				System.out.println("车修好了给钱");
			}else {
				System.out.println("修好了");
			}
			return c;
		}
	}
	public class 随便试一试 {
	public static void main(String[] args) {
		Car c = new Car();
		//给车对象赋予属性值
		c.name="比亚迪";
		c.color="黑色";
		c.wheel=4;
		c.run();
		//创建修车厂对象
		CarFactory f = new CarFactory();
		//给修车厂赋予属性值
		f.name="阿强修车厂";
		f.address="咸阳人民广场";
		f.tel="020-87839";
		//调用修车的
		c = f.repair(c);
		//
		c.run();
/*运行结果：
 比亚迪飞快跑起来了
车修好了给钱
比亚迪飞快跑起来了
 */
}
}

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

定义的位置上的区别：
1：成员变量是定义在方法之外，类之内的。
2：局部变量是定义在方法之内。
作用上的区别：
1：成员变量的作用是用于描述一类事物的公共属性的。
2：局部变量的作用就是提供一个变量给方法内部使用而已。
生命周期的区别：
1：成员变量随着对象的创建而存在，随着对象的消失而消失。
2：局部变量在调用了对应的方法时执行到了创建该变量的语句时存在，
局部变量一旦出了自己的作用域就马上从内存中消失。
初始值的区别：
1：成员变量是有默认的初始值。
数据类型 默认的初始值
int 0
float 0.0f
double 0.0
boolean false
char ’ ’
String(引用数据类型) null

	2：局部变量是没有默认的初始值的，必须要先初始化才能用。

匿名对象：没有引用类型变量指向的对象称作为匿名对象。

匿名对象要注意的事项：
1：一般不会给匿名对象赋予属性值，因为永远无法获取到。
2：两个匿名对象永远都不可能是同一个对象。
匿名对象的应用场景：
1：如果一个对象需要调用一个方法，而调用完这个方法之后，该对象就不再使用了，这时候可 以使用匿名对象。
2:可以作为实参调用一个函数。
匿名对象的好处：简化书写。

** 需求：使用java类描述一个学生类。**

package demo;
//学生类
class Student{
	int num; //学号
	String name;//姓名
	public void study() {
		System.out.print("好好学习为将来成为高富帅做准备！");	
	}	
}
public class day06_匿名对象 {
	public static void main(String[] args) {
	//创建一个学生对象
	//Student s = new Student();
	new Student().name = "狗娃";//匿名对象
	//System.out.println(new Student().name);
	//运行为：null，一般不会给匿名对象赋予属性值，因为永远无法获取到。
	//System.out.println(new Student()==new Student());
	//运行为：false，因为两个匿名对象永远都不可能是同一个对象。
	//"=="用于引用类型变量时，比较的是内存地址。判断两个对象是否为同一个对象。  

	//需求：调用Student的study方法。
		/*Student s =new Student();
		s.study(); 
		这个方法等同于下面这个方法 */
		new Student().study();
}
}

封装

面向对象三大特征：
1：封装
2：继承
3：多态
权限修饰符： 权限修饰符就是控制变量等其他东西的可见范围。
public：公共的。public修饰的成员变量或者方法任何人都可以访问。
private:私有的。private修饰的成员变量或者方法只能在本类中进行直接访问。
封装的步骤：
1：使用private修饰需要被封装的属性
2:提供一个公共的方法设置或者获取该私有的成员属性
命名规范：
set属性名();
get属性名();
封装的好处：
1：提高数据的安全性
2：操作简单
3；隐藏了实现

封装一定要提供get或者set方法吗？
不一定，根据需求而定。

规范:在现实开发中，一般实体类的所有成员变量(属性)都要封装起来。
实体类：就是用于描述一类事物的就称为实体类。

需求：使用java类描述百合网的会员。

package demo;
class Member{
	public String name;//名字
	private String sex;//性别
	public int salary;//薪水
	int age;
	//定义一个公共的方法设置sex属性
	public void setSex(String s) {
		if(s.equals("男") || s.equals("女")) {
 //注意:如果比较两个字符串的内容是否一致，不要使用"=="比较，使用equals方法;
			sex=s;
		}else {
			sex="男";//默认性别为男。
		}
	}
	public String getSex() {
		return sex;
	}
	public void talk(){
		System.out.println(name+"聊得非常开心");	
	}
}
public class day06_封装 {
	public static void main(String[] args) {
		Member m = new Member();
		m.name="狗娃";
		m.setSex("人妖");
		m.salary=800;
		System.out.println("姓名："+m.name+"性别:"+m.getSex()+"薪水："+m.salary);
		//运行结果：         姓名：狗娃性别:男薪水：800
	}
}

package demo;
/*
 需求：使用java类描述一个计算器类，计算器具备操作数1，操作数2，操作符三个公共的属性
 还具备运算的功能行为。
 要求：不能直接对操作数1，操作数2，运算符这些属性进行直接的赋值，要封装起来。(+ - *  /)
 根据需求提供get或者set方法。
 需要提供set方法。
 */
public class day06_封装2 {
	public static void main(String[] args) {
		//创建一个计算机对象
		Calculator c = new Calculator();
		//设置属性值
		c.initCalculator(2,4,'*');
		//调用计算器的计算功能
		c.calculate();
	}
}
class Calculator{
	private int num1;
	private int num2;
	private char option;
	//提供公共方法，设置属性值
	public void initCalculator(int n1,int n2, char o) {
		num1=n1;
		num2=n2;
		if(o=='+'||0=='-'||o=='*'||o=='/') {
			option=o;
		}else {
			option='+';
		}
	}
	//计算功能
	public void calculate() {
		switch(option) {
		case '+':
			System.out.println("结果为"+(num1+num2));
			break;
		case '-':
			System.out.println("结果为"+(num1-num2));
			break;
		case '*':
			System.out.println("结果为"+(num1*num2));
			break;
		case '/':
			System.out.println("结果为"+(num1/num2));
			break;
		}	
	}
}
//运行结果：结果为8