七、JAVA三大特性



面向对象三大特性  封装，继承和多态

封装 

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面(方法)。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术。

封装是分为两部分：属性的封装，方法的封装。封装起来就是为了对外隐藏。

类本身和方法本身就是一种封装，体现的是装配的含义。

在java中通过关键字private实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

属性的封装通过private，同时还要提供可以访问该私有属性的方法。

这个方法就要写在类里面。

Java里面对私有属性提供了两个方法：setter和getter，而且这两个方法必须是public。

package yantai;

import java.util.Scanner;

public class Account
{

private double balance=100;

private String
cardNo;

public double getBalance()
{

///

Scanner
s=new Scanner(System.in);

System.out.println("请输入密码");

String
passwd =
s.next();

if(!passwd.equals("ok")){

System.out.println("输入密码不正确....");

throw new RuntimeException();

}

return balance;

}

public void setBalance(double balance)
{

this.balance =
balance;

}

public String
getCardNo() {

return cardNo;

}

public void setCardNo(String
cardNo) {

this.cardNo =
cardNo;

}

/**

*
存款

*/

public void deposit(int money){

this.balance=this.balance+money;

System.out.println("存了："+money);

System.out.println("目前卡余额："+this.balance);

}

/**

*
取款

*/

public  void withdraw(int money){

this.balance=this.balance-money;

System.out.println("取了："+money);

System.out.println("目前卡余额："+this.balance);

}

public static void main(String[]
args) {

//先创建一个对象，对象名字叫小明

Account
a =
new Account();

System.out.println(a.balance+"-----------");

a.deposit(100);

a.withdraw(200);

}

}

继承

使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，同时也拥有了父类的功能，使得复用以前的代码非常容易，减少重复代码的编写。能够大大缩短开发周期

父类：（超类）被继承

子类：（派生类）继承父类，并有自己新的特性。

什么时候适合设计成类之间的继承关系？

1. 为了重复利用代码
2. 这两个类之间有一种is a关系

   子类对象构建过程：

   定义子类对象时：

   分配空间 （父类对象空间，子类对象空间）

   递归构造父类对象

   初始化属性

   调用构造方法：先调用父类的构造方法再调用子类的构造方法

   子类可以把父类的什么修饰符修饰的属性和方法继承过来。Public,protected,default(父类和子类在同一个包)。

   访问修饰符

   一共是四种：public ,protected—为了继承,default,private

   子类：派生类

   父类：超类

    

   方法的重载（Overload）

   涉及到一个类，要求这些方法的方法名一样，但是参数不同。

   方法都在同一个类里面。

   方法的覆盖(Override)

   前提是需要有继承关系，涉及到两个类，父类和子类。

   方法重写：

1. 子类重新定义父类的同名方法，主要是重写定义方法体。
2. 父类是公有的修饰符，子类一定是公有的。父类如果是protected，子类可以是protected，或者public

   子类比父类更开放。

   3.子类重写的方法的返回值类型可以是跟父类一样，或者是父类返回值类型的子类。

   super关键字（this关键字
    ---当前对象）

    

   可以通过super.属性名调用从父类继承过来的属性

   通过super.方法名调用父类定义的方法

   通过super()调用父类的构造方法。

   定义子类对象，调用父类的构造方法的时候，一定子类构造方法的第一行，并且不一定就是调用空参数的父类的构造方法，只要是调用父类随便一个构造方法都可以，但是，只能调用一次。

    

   public Dog(){

   super(30);//首先调用父类的无参的构造方法

   System.out.println();

   }

    

   Java继承的限制：

   1.继承只能是单继承，只能有一个直接父类。 只能有一个爹

   2.可以多层继承，父类有父类 爷爷

   3.私有的属性和方法不能被继承  私有就是为了自己类可用，子类当然不能用

    

   课堂代码：

   public class Animal {

   public Animal(int age,
   char sex)
   {

   this.age =
   age;

   this.sex =
   sex;

   }

   public Animal(){

   System.out.println("---------Animal
   Constructor-----------");

   }

   protected  int age=0;

   private char sex;

   public int getAge()
   {

   return age;

   }

   public void setAge(int age)
   {

   this.age =
   age;

   }

   public char getSex()
   {

   return sex;

   }

   public void setSex(char sex)
   {

   this.sex =
   sex;

   }

   /**

   *
   吃饭

   */

   public  void eat(){

   System.out.println("I
   can eat");

   }

   /**

   *
   睡觉

   */

   protected   void sleep(){

   System.out.println("I
   can sleep 8 hours");

   }

   /**

   *
   发出叫声

   */

   public  void call(){

   System.out.println("call.......................");

   }

   public Animal getAnimalInstance(){

   return new Animal();

   }

   }

    

    

   package yantai;

   public class Dog
   extends Animal{

   int age=1;

   @Override

   public Dog getAnimalInstance() {

   //
   TODO Auto-generated method stub

   return null;

   }

   @Override

   public  void sleep()
   {

   //
   TODO Auto-generated method stub

   System.out.println("8
   hours");

   }

   public Dog(){

   super(12,‘f‘);

   System.out.println("------Dog
   constructor---------");

   }

   /**

   *
   看门

   */

   public void watchDoor(){

   System.out.println("I
   can watchDoor");

   }

   public void print(){

   System.out.println("the
   age is :"+super.age);

   }

   }

    

多态 

多态需要具备什么前提？

1. 类之间有继承关系
2. 多个子类需要对父类的某个方法进行重写。

   3.一个父类的引用指向一个子类的对象。

   Animal a =  new Dog();

   Animal a =  new Cat();

   Animal a =  new Pig();

   多个子类共同继承父类，定义时候用父类变量分别指向不同子类对象

   注意：

1. 父类的引用指向子类的对象，但是父类的引用只能访问到父类定义的方法声明。
2. 他访问父类当中被重写的方法，最终是访问子类的方法。

   多态总结：一个变量能做什么要由类型决定，一个变量怎么做由对象决定。

    

   深度分析: invokespecial选择方法基于引用的类型，而不是对象所属的类。但invokevirtual则选择当前引用的对象

    

    

    

    

    

    

   课堂举例：动物发出叫声的多态----玩具

    

    

   package com;

   public class Animal {

   private int age;//年龄

   private char sex;//性别

   private String
   skin;//肤色

   private String
   type;//类型

   public Animal(){

   }

   /**

   *
   睡觉

   */

   protected void sleep(){

   System.out.println("-------------sleep
   8 hours---------------");

   }

   /**

   *
   吃饭

   */

   public void eat(){

   System.out.println("-------------eat
   something---------------");

   }

   /**

   *
   叫声

   */

   public void call(){

   System.out.println("-------------calling....---------------");

   }

   }

   class Dog
   extends Animal{

   public void call(){

   System.out.println("-------------wangwang....---------------");

   }

   }

   class Pig
   extends Animal{

   public void call(){

   System.out.println("-------------hengheng....---------------");

   }

   }

   class Cat
   extends Animal{

   public void call(){

   System.out.println("-------------miaomiao....---------------");

   }

   }

    

    

    

   Toy.java

    

   package com;

   public class Toy {

   public static void main(String[]
   args) {

   //
   TODO Auto-generated method stub

   Toy toy=new Toy();

   toy.pressButton(new Dog());

   toy.pressButton(new Cat());

   }

   public static void pressButton(Animal
   a){

   //根据信号来判断这是什么动物，然后发出声音

   a.call();

   }

   }

    

    

   台灯发光的问题。

   一盏台灯，换上不同颜色的灯泡会发出不同颜色的光。