Java开发实战经典第五章——面向对象基础

                         Java开发实战经典第五章——面向对象(基础)

1. JAVA是一门面向对象的计算机编程语言，较面向过程的语言大大提高了代码的开发效率，那什么是对象？具体的使用方法又是什么？JAVA又是如何通过对象反映现实世界的问题？

2. 对象在现实世界是一个具体的实体，类（class）是对象的抽象，对象是类的实体，类就是对象的模板，比如人在java是一个类，你梦寐以求的女（男）朋友就是这个类的对象，直接New一个对象就行，你可以设置他/她的身高，三围，年龄等等这些信息在面向对象中称为属性，他/她吃饭之类的行为称为方法。

   package java开发实战经典第五章;
   
   public class Person {// 一个Person类
   	String name;// 设置姓名属性
   	int age;// 设置年龄属性
   
   	public void sleep() {// 设置取得信息的方法
   		System.out.println(age + "岁" + "的" + name + "叫你一起睡觉");
   	}
   
   	public static void main(String[] args) {
   		Person per = null;// 声明对象
   		per = new Person();// 实例化对象
   		per.name = "java";// 为name赋值
   		per.age = 27;// 为age属性赋值
   		per.sleep();// 调用类中的方法
   	}
   }
   

   3.面向对象的三大特征------封装，继承和多态一：封装的含义：把描述对象属性的变量及实现对象功能的方法合在一起，定义为一个程序单位，保证外界不能任意更改其内部的属性值，也不能任意调动其内部的功能方法。

3. 1. 关键字：private 私有的，只允许在当前类中使用,无法通过调用对象名属性进行赋值,只能通过方法的方式给属性赋值 ---set(),无法通过对象名.属性获取属性值，只能通过get();

   2. public class Buyer {
      	//类属性
      String name;
       private int age;//私有化年龄
      //类方法
      public void buy() {
      	System.out.println(age+"岁的"+name+"去采购");
      }
      //设置价格
      public void setAge(int a){//赋值
      	age=a;
      	if(a<18) {
      		age=18;	
      	}else {
      		age=a;
      	}
      }
      public int getAge() {//取值
      	return age;
      }
      }
      
      package javasedemo;
      
      public class classTest2 {
      
      	public static void main(String[] args) {
      		//创建对象并实例化
      		Buyer Test=new Buyer();
      		Test.name="xiaobai";
      
      //		   Test.age=-18;
      		   //通过方法的方式给属性赋值
      		   Test.setAge(-19);//通过对象set（）赋值
      		   //通过对象的属性赋值
      //		   Test.age=-18;
      		//调用对象的方法
      Test.buy();
      System.out.println(Test.getAge()+"岁的");//通过对象get()取值
      	}
      
      }
      //结果是：18岁的xiaobai去采购

      二.继承：语法：class 父类｛｝class 子类extends 父类｛｝

   • 类直接或间接都是继承Object

   2.功能越精细，重合点越多，越接近直接父类；功能越粗略，重合点越少，越接近object类（万物都是对象）

   3.关键词是extends--减少重复的代码，提高了代码的复用性

   1. 1.子类继承父类，只允许单继承，不能多继承

      2.子类继承父类，只能够继承非私有的方法和属性，

      3.子类继承父类，父类的构造方法不能被继承（构造方法只负责创建本类对象）

      4.子类的构造方法会默认存在super(),用来创建父类的对象

      5.子类创建对象的时候会先创建父类对象

      6.父类和子类不在同一个包中，default修饰的属性和方法不可继承

      1.public class Animal {
      private String name;
      private int age;
      public Animal() {
      	
      }
      public Animal(String name,int age) {
      this.name=name;
      this.age=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;
      
      }
      @Override
      public String toString() {
      	return "Animal [name=" + name + ", age=" + age + "]";
      }
      
      
      }
      
      2.package javaxuexibiji08_OPP1_opp2;
      
      public class Cat  extends Animal{
      public static void main(String[]args) {
      	Cat cat=new Cat();
      	cat.setName("白猫");
      	cat.setAge(5);
      	System.out.println(cat.toString());
      }
      }
      //结果：Animal [name=白猫, age=5]

      三：多态

   2. 含义：多态是同一个行为具有多个不同表现形式或形态的能力。

   3. 多态存在的三个必要条件 1.继承 2.重写  3.父类引用指向子类对象

   class A{
       public void fun1(){//定义fun1()方法
           System.out.println("A--->public void fun1(){}");
       }
       public void fun2(){//定义fun2()方法
           this.fun1();    
       }
   };
   class B extends A{
       public void fun1(){//重写父类中的fun1{}方法
          System.out.println("B--->public void fun1(){}");
       }
       public void fun3(){//定义子类自己的方法}
          System.out.println("B--->public void fun3(){}");
       }
   };
   class C extends A{
       public void fun1(){//重写父类中的fun1{}方法
          System.out.println("C--->public void fun1(){}");
       }
         public void fun5(){//定义子类自己的方法}
          System.out.println("C--->public void fun5(){}");
       }
   };
   public class DuoTai{
       public static void main(String[] args){
       fun(new B());//向上转型.传递B实例
   		 fun(new C());//向上转型。传递C实例    
   		}
   		    public static void fun(A a){
   		    a.fun1(); //接受父类对象
   		    }
   		}
   结果：B--->public void fun1(){}
   C--->public void fun1(){}