java--第七章 面向对象1

1 概述

面向过程：面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

面向对象：强调的是对象，是基于面向过程的编程思想。

面向对象思想特点：

   A：是一种更符合我们思想习惯的思想

   B:  可以将复杂的事情简单化

   C:  将我们从执行者变成了指挥者

举例：买电脑

      面向过程：了解电脑--了解我的需求--找对应的参数信息--去中关村--讨价还价--买回电脑

      面向对象：知道要买电脑--班长去给我买--买回来了

万事万物皆对象

把大象装进冰箱案例：

  面向过程：打开冰箱门open()--装进大象in()--关闭冰箱门close()

class DEMO{
   public static void main(String[] args){
       open();
       in();
       close();
   }

   public static void open{
       System.out.println("打开冰箱门");
   }

   public static void in{
       System.out.println("装进大象");
   }

   public static void close{
       System.out.println("关闭冰箱门");
   }
}

  面向对象：(UML,名词提取法)

        A:有哪些类呢？

            大象、冰箱、DEMO

        B:每个类有哪些东西呢？

            大象：进去

            冰箱：开门、关门

            DEMO:main方法

        C:类与类之间的关系是什么呢？

           DEMO中使用大象和冰箱类的功能

class 大象{
   public static void in{
       System.out.println("装进大象");
   }
}

class 冰箱{
   public static void open{
       System.out.println("打开冰箱门");
   }

   public static void close{
       System.out.println("关闭冰箱门");
   }
}

class DEMO{
   public static void main(String[] args){
       冰箱调用开门
       大象调用进去
       冰箱调用关门
   }
}

面向对象开发：不断的创建对象，使用对象，指挥对象做事情。

面向对象设计：管理和维护对象之间的关系。

面向对象特征：封装、继承、多态

类与对象：

java中最基本的单位是类。

类：是一组相关的属性和行为的集合，是一个抽象的概念。

对象：是该类事物的具体表现形式，具体存在的个体。

举例：类：学生

           对象：班长

2 类

定义一个类其实就是定义类的成员变量和成员方法。

成员变量：和以前变量的定义是一样的格式，但是位置不同，在类中方法外。

成员方法：和以前方法的定义是一样的格式，但是今天把static先去掉。

学生类的定义：

/*
  学生类的定义
*/
class StudentDemo{
	//定义变量
	String name;
	int age;
	String address;
	
	//定义方法
	public void study(){
		System.out.println("学生爱学习");
	}
	
	public void eat(){
		System.out.println("学习饿了要吃饭");
	}
	
	public void sleep(){
		System.out.println("学习累了要睡觉");
	}
}

手机类的定义：

/*
  手机类的定义
*/
class PhoneDemo{
	//定义变量
	String brand;
	int price;
	String color;
	
    //定义方法
	public void call(String name){
		System.out.println("给"+name+"打电话");
	}
	
	public void sendMessage(){
		System.out.println("群发短信");
	}
	
	public void playGame(){
		System.out.println("玩游戏");
	}
}

学生类的使用：

*
  在一个java文件中写两个类：一个基本的类，一个测试类。
  注意：文件名称和测试名称一致。
*/

//学生类
class Student{
	String name;    //null
	int age;        //0
	String address; //null
	
	public void study(){
		System.out.println("学生爱学习");
	}
	
	public void eat(){
		System.out.println("学习饿了要吃饭");
	}
	
	public void sleep(){
		System.out.println("学习累了要睡觉");
	}
}

//学生测试类
class StudentUse{
	public static void main(String[] args){
		//类名 对象名=new 类名();
		Student s=new Student();
		
		//输出成员变量值
		System.out.println(s.name+"--"+s.age+"--"+s.address);
		
		//给成员变量赋值并输出
		s.name="小朋友";
		s.age=27;
		s.address="北京";
		System.out.println(s.name+"--"+s.age+"--"+s.address);
		
		//调用方法
		s.study();
		s.eat();
		s.sleep();
	}
}

手机类的使用：

/*手机类的使用*/

class Phone{
	//定义变量
	String brand;
	int price;
	String color;
	
    //定义方法
	public void call(String name){
		System.out.println("给"+name+"打电话");
	}
	
	public void sendMessage(){
		System.out.println("群发短信");
	}
	
	public void playGame(){
		System.out.println("玩游戏");
	}
}

class PhoneUse{
	public static void main(String[] args){
		Phone p=new Phone();
		
		//输出成员变量
		System.out.println(p.brand+"--"+p.price+"--"+p.color);
		
		//给成员变量赋值并输出
		p.brand="华为";
		p.price=1000;
		p.color="灰色";
		System.out.println(p.brand+"--"+p.price+"--"+p.color);
		
		//调用方法
		p.call("老大");
		p.sendMessage();
		p.playGame();
	}
}

3 对象

一个对象的内存图

二个对象的内存图：方法共用

三个对象的内存图：其中有两个引用指向同一个对象

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

	成员变量	局部变量
在类中的位置不同	类中方法外	方法内或者方法声明上
在内存中的位置不同	堆内存	栈内存
声明周期不同	随着对象的存在而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同	有默认的初始化值	没有默认的初始化值，必须先定义，赋值，才能使用

注意事项：

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

//成员变量和局部变量的区别
class Variable{
	//成员变量
	//int num=10;
	int num;
	
	public void show(){
		//int num2=20; //局部变量
		//可能尚未初始化变量num2
		int num2=20;
		System.out.println(num2);
		
		//int num=100;
		System.out.println(num);
	}
}

class VariableDemo{
	public static void main(String[] args){
		Variable v=new Variable();
		
		System.out.println(v.num);//0
		v.show();//20
	}
}

形式参数问题：

基本类型：形式参数的改变不影响实际参数

引用类型：形式参数的改变直接影响实际参数

//形式参数问题

//形式参数是基本类型
class Demo{
	public int sum(int a,int b){
		return a+b;
	}
}

//形式参数是引用类型
class Student{
	public void show(){
		System.out.println("我爱学习");
	}
}

class StudentDemo{
	//如果你看到了一个方法的形式参数是一个类类型(引用类型),
	//这里其实需要的是该类的对象。
	public void method(Student s){//调用的时候，把main方法中s的地址传到了这里
		s.show();
	}
}

class ArgsTest{
	public static void main(String[] args){
		//形式参数是基本类型的调用
		Demo d=new Demo();
		int result=d.sum(10,20);
		System.out.println(result);
		
		//形式参数是引用类型的调用
		StudentDemo sd=new StudentDemo();
		Student s=new Student();
		sd.method(s);//把s的地址给到了这里
	}
}

匿名对象的概述和应用：

匿名对象：就是没有名字的对象，是对象的一种简化形式

匿名对象的两种使用情况：

       A：对象调用方法仅仅一次的时候

             调用多次的时候不适合

             好处：匿名对象调用完毕就是垃圾，可以被垃圾回收器回收。

       B：匿名对象可以作为实际参数传递

/*匿名对象*/
class Student{
	public void show(){
		System.out.println("我爱学习");
	}
}

class StudentDemo{
	public void method(Student s){
		s.show();
	}
}

class NoName{
	public static void main(String[] args){
		Student s=new Student();
		s.show();
		
		//匿名对象
		//new Student();
		
		//匿名对象调用方法,仅仅调一次
		new Student().show();
		new Student().show();//这里其实是重新创建了一个新的对象
		
		//匿名对象作为实际参数传递
		StudentDemo sd=new StudentDemo();
		//Student ss=new Student();
		//sd.method(ss);
		//sd.method(new Student());
		new StudentDemo().method(new Student());
	}
}

封装：

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

封装好处：

   A:隐藏实现细节，提供公共的访问方式

   B:提高了代码的复用性

   C:提高安全性

封装原则：

把不需要对外提供的内容都隐藏起来；把属性隐藏，提供公共方法对其访问。

/*
   发现一个问题：
      通过对象给成员变量赋值，可以赋值一些非法的数据。这是不合理的。
      应该在赋值之前先对数据进行判断。那应该在哪里做判断呢？
	      StudentDemo是一个测试类，测试类一般只创建对象，调用方法
		  所以这个判断应该定义在Student中。
		  做数据校验必须要依靠一些逻辑语句，逻辑语句应该定义在方法中。
	  这个方法定义了，要求必须使用方法，不能直接调用成员变量值。
	  这种情况提供了一个关键字：private
	  private:私有的，可以修饰成员变量和成员方法。
	  被private修饰的成员只能在本类中访问。
*/
class Student{
	String name;
	private int age;
	
	//写一个方法对数据校验
	public void setAge(int a){
		if(a<0 || a>120){
			System.out.println("年龄有问题");
		}else{
			age=a;
		}
	}
	
	public void show(){
		System.out.println("姓名："+name);
		System.out.println("年龄："+age);
	}
}

class StudentDemo{
	public static void main(String[] args){
		Student s=new Student();
		s.show();
		
		s.name="啦啦啦";
		//s.age=27;
		s.setAge(27);
		s.show();
		
		//s.age=-27;//这个数据是不合理的
		s.setAge(30);
		s.show();
	}
}

private关键字：

是一个权限修饰符，可以修饰成员(成员变量和成员方法)，被private修饰的成员只能在本类中才能访问。

常见的应用：

把成员变量用private修饰；提供对应的getXxx()或setXxx()方法。

class Demo{
	//私有的成员变量
	private int num=10;
	
	public void show(){
		System.out.println(num);
	}
	
	//私有的成员方法
	private void method(){
		System.out.println("method");
	}
	
	public void function(){
		method();
	}
}

class PrivateDemo{
	public static void main(String[] args){
		Demo d=new Demo();
		//d.num; //报错
		d.show();
		
		//d.method(); //报错 
		d.function();
	}
}

private常见应用：

class Student{
	private String name;
	private int age;
	
	//获取值
	public int getAge(){
		return age;
	}
	public String getName(){
		return name;
	}
	
	//赋值
	public void setName(String n){
		name=n;
	}
	
	public void setAge(int a){
		age=a;
	}
}

class PrivateTest{
	public static void main(String[] args){
		Student s=new Student();
		
		//System.out.println(s.name); //外界不能直接访问
		System.out.println(s.getName()+"--"+s.getAge());
		
		//给成员变量赋值
		s.setAge(27);
		s.setName("我");
		System.out.println(s.getName()+"--"+s.getAge());
	}
}