Java程序猿必学第七篇——面向对象编程

/*
1.类和对象（重点）
引入：在程序的世界中一切皆为对象

面向对象和面向过程思想：
面向过程：关注做了什么事，而不关心是谁做的
面向对象：关注谁做了这件事
          

生活案例：
面向过程：白白的皮肤，修长的腿；特能吃
          String color = "白色";
          double height = 1.5;
          eat();  //吃的方法

面向对象：佩奇的特征--肤白，腿长， 行为-能吃
          Dog  peiQi = new Dog();
          peiQi.color = "白色";  //特征
          peiQi.height = 1.5;
          peiQi.eat();           //行为

面向对象描述：世间万物皆为对象，每个对象都有特征和行为
          特征：以名词形式出现--属性
          行为：以动词形式出现--方法 

什么是对象：具体化的一个实体
什么是类：所有实体共同组成的集合

类的抽取：相似的对象共同特征和行为可以进行抽取，放入类中；表示一类事物的特征与行为 
   例如： 泰迪，藏獒等对象都有姓名，年龄及吃的行为，可以将他们放到狗类中



2. 面向对象编程(重点)
注意：在现实中有什么具体案例，那么我们就可以通过代码来实现

面向对象的编程设计：（重点）
创建一个类，类中有属性和方法，实例化对象，通过对象调属性和方法
*/

//=====================面向对象编程设计=====================
//案例：家里养了一条叫旺财的狗，特能吃
//分析： 类-狗类             对象-new对象          属性：姓名             方法：吃

//1.创建一个狗类
public class Dog {
	//2.类中有属性
	String name;  //旺财
	
	//3.类中有方法
	public void eat() {
		System.out.println(name+"特能吃...");
	}
}

public class Test {
	public static void main(String[] args) {
		//1.实例化狗的对象
		Dog dog = new Dog();
		dog.name = "旺财";  //赋值 对象调属性 ： 对象.属性
		System.out.println(dog.name);  //取值
		dog.eat();         //旺财能吃？
	}
}

 




//=====================创建多个实例=====================
public class Test {
	public static void main(String[] args) {
		//1.实例化狗的对象
		Dog dog = new Dog();
		
		dog.name = "旺财";  //赋值 对象调属性 ： 对象.属性
		
		System.out.println(dog.name);  //取值
		
		
		//2.实例化另一个狗对象
		Dog dog2 = new Dog();
		dog2.name = "小藏";
		
		dog.eat();         //旺财能吃？
		dog2.eat();         //小藏能吃？
		
	}
}

 




//3. 局部变量与成员变量（重点）

//局部变量与成员变量的区别：
//1.出现位置：
//局部变量：定义在方法体中，方法参数中，代码块中
//成员变量：在类中，且在成员方法外部

//2.初始值：
//局部变量：没有初始值，不赋值则报错
//成员变量：有初始值；  String-null，int-0

//3.作用域：
//局部变量： 在方法体中，出了方法，则销毁
//成员变量：至少在当前类中（成员变量有权限问题）

//4.重名问题
//出现重名，重叠作用域，局部变量优先（作用域小的覆盖作用域大的）



//=======================女朋友洗衣服案例=======================
class GirlFriend{
	//属性的初始值问题：  String-null   int-0 与数组类似
	String name;   //成员属性(成员变量)
	int    age;
	
	public void wash() {  //成员方法
		String name="凤姐";
		System.out.println(age+"岁的女朋友"+name+"正在洗衣服");
	}
}

//案例：女朋友小丽正在帮我洗衣服
//分析： 类：女朋友类   对象： new    属性： 姓名,年龄     方法：洗衣服    
public class Test {
	public static void main(String[] args) {
		GirlFriend gf = new GirlFriend();  //实例化对象
		gf.name = "小丽";   //给属性赋值
		gf.age  = 18;
		
		gf.wash();        //调方法
	}
}



//=======================打印学生信息案例=======================

//案例：创建一个学生类：
//属性有：姓名，年龄，性别，分数    方法： 打招呼（打印所有属性信息）
//实例化多个对象，并赋值及打印

public class Student {
	
	String name;   //null
	int    age;    //0
	char   sex;    //空格
	double score;  //0.0
	
	public void sayHi() {
		System.out.println("姓名:"+name);
		System.out.println("年龄:"+age);
		System.out.println("性别:"+sex);
		System.out.println("分数:"+score);
	}
}

public class Test {
	public static void main(String[] args) {
		//实例化第一个对象
		Student st = new Student();
		st.sayHi();
		
		System.out.println("--------------");
		
		//实例化第二个对象
		Student st2 = new Student();
		st2.name = "李凯";
		st2.age  = 18;
		st2.sex  = '男';
		st2.score = 88;
		
		st2.sayHi();
	}
}


//4. 方法重载(重点)

//概述：在同一个类中，方法名相同，参数个数或类型不同
//好处：方便统一管理相关功能
//案例：小明在吃饭，在吃药
//类： Person类     对象： new  属性：姓名   方法： 吃

class Person{
	String name;
	
	//------------方法重载--------------
	public void eat(String rice) {
		System.out.println(name+"在吃"+rice);
	}
	
	public void eat(String rice,String yao) {
		System.out.println(name+"在吃"+rice+";吃完后，有在吃"+yao);
	}
	
	public void eat(int number) {
		System.out.println(name+"在吃"+number);
	}
	
	//下面的是否为重载方法?
	/* 
	//注意： 返回值不同，及参数名不同不是重载
	public int eat(String fish) {
		return 0;
	}*/

	//关于jvm调用：1.方法调用时，先通过方法名确定，调哪个方法；2.如果方法名相同，则看参数列表
	
}





//5. 构造方法（重点）

//案例：手机有打电话功能
//类：手机类      对象：new  属性：品牌，价格    方法： 打电话

//实例化对象的过程：
//1.在内存中开辟了一块空间
//2.给成员属性赋予初始值
//3.调用构造方法实现
//4.将地址赋值给引用变量


//构造方法：特殊的方法，在实例化对象时进行调用
//组成部分：1.构造方法调用  2.构造方法实现
//1.构造方法调用:  new 类名();
//2.构造方法实现:  public 类名(){};

//注意：
//1.当我们没有写构造方法实现，系统会默认生成无参数构造方法--查看反编译工具
//2.当我们写了构造方法实现，系统则不会默认生成构造方法

class Phone{
	//成员属性：
	String brand;
	int    price;
	
	
	//----------构造方法也具备重载的特点----------
	
	public Phone() {  //无参构造的实现
		System.out.println("调用无参构造");
	}

	//带参构造：往往带参构造用于给成员属性赋值
	public Phone(String b, int p) {
		brand = b;
		price = p;
	}
	
}

public class Test {
	public static void main(String[] args) {
		//1.无参构造
		Phone phone = new Phone();
		phone.brand = "华为";
		phone.price = 1999;
		System.out.println(phone.brand+"=="+phone.price);
		
		
		System.out.println("--------------");
		//2.带参构造：  new 类名(参数)
		//带参构造 = 无参构造+赋值
		Phone phone2 = new Phone("三星",3999);
		System.out.println(phone2.brand+"-->"+phone2.price);
		
	}
}

 




//6. this用法（重点）

//案例：创建汽车类   属性有： 品牌，价格    方法： 启动
//this：当前对象，就是谁调用this所在的方法，this就代表那个对象
//this用法：
//this调属性： this.属性-当前对象的属性
//this调方法：this.方法()
//this调构造方法： 调无参-this()   调带参-this(参数)
class Car{
	//属性
	String brand;
	int    price;
	
	public Car() {
		System.out.println("调无参构造..");
	}
	
	public Car(String brand) {
		this.brand = brand;
	}
	
	//带参构造的规范写法：往往参数要与属性名一致
	public Car(String brand, int price) {
		//this(); //this调构造方法，只能在构造器中，且放在首句
		this(brand); //不能重复使用this调构造方法，因为都要放首句，重复调则会冲突
		//brand = brand;  //注意：此处局部变量优先，所以赋值给了自身，跟成员变量无关
		this.price = price;
		
		//this.start();  //当前对象调start
		
	}
	
	public void start() {
		
		System.out.println("汽车启动...");
	}
}

public class Test {
	public static void main(String[] args) {
		Car car = new Car("奥迪",30);
		
		//car.start();  //等价于在带参构造中通过this.start();
		
		System.out.println(car.brand+"  "+car.price);  //奥迪   30
		
	}
}