Java第二季

1、封装

（1）概念

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

（2）封装的实现步骤

2、Java中的访问修饰符

3、继承

（1）Java中是单继承

（2）继承的好处：

（1）子类拥有父类的所有属性和方法

　　（2）实现代码复用

（3）继承的语法规则：

　　

（4）方法重写：

什么是方法的重写

如果子类对继承父类的方法不满意，是可以重写父类的继承的方法的，当调用方法时会优先调用子类的方法。

（5）继承的初始化顺序

初始化父类再初始化子类。

先执行初始化对象中的属性，再执行构造方法中的初始化。

（6）java中final的使用

final关键字

使用final关键字做标识有“最终的”含义。

final可以修饰类、方法、属性和变量。

修饰类，该类不允许被继承

修饰方法，该方法不允许被覆盖或重写

修饰属性，系统不会对其进行隐式初始化（类的初始化属性必须有值），所以必须赋值或者在构造方法中赋值

修饰变量，该变量只允许被赋值一次，该变量成为常量

（7）Java中的super的使用

super关键字：

在对象的内部使用，可以代表父类对象。

1、访问父类的属性

super.age

2、访问父类的方法

super.eat()

   子类的构造的过程当中必须调用其父类的构造方法 相当于super();默认是调用无参的
   如果子类的构造方法中没有显示调用父类的构造方法,系统会默认调用父类无参的构造方法.
   如果要显示的调用父类的构造方法,必须在子类的构造方法第一行中添加super();
   如果子类构造方法中既没有显示调用父类的构造方法,而父类又没有无参的构造方法,则编译出错.

（8）Java中的Object类

    Object类是所有类的父类,如果一个类没有使用extends关键字明确标识继承另外一个类,那么这个类默认继承Object类,且Object类中的方法适合     所有子类。

1、toString()方法

    在Object类里面定义toString()方法的时候返回的对象的哈希code码(对象地址字符串)。

    如果我们在代码里面直接输出一个对象,会输出这个对象在内存中的地址,我们把它称为哈希码,哈希码是通过哈希算法生成的一个字符串用来.    唯一区分对象的。
    可以通过重写toString()方法表示出对象的属性。

2、equals()方法
    比较的是对象的引用是否是指向同一块内存地址。
    一般情况下比较两个对象时比较他的值是否一致，所有要进行重写。

public static void main(String[] args)
{
     Dog dog = new Dog();
     Dog dog2 = new Dog();
     if(dog.equals(dog2))
     {
          System.out.print("两个对象都是相同的");
     }
     else
     {
          System.out.print("两个对象都是不相同的");
     }
}

重写equals方法：

public static void main(String[] args)
{
     Dog dog = new Dog();
     Dog dog2 = new Dog();
     if(dog.equals(dog2))
     {
          System.out.print("两个对象都是相同的");
     }
     else
     {
          System.out.print("两个对象都是不相同的");
     }
}

4、多态

（1）引用多态

父类的引用可以指向本类的对象

父类的引用可以指向子类的对象

（2）方法多态

创建本类对象时，调用的方法为本类方法

创建子类对象时，调用的方法为子类重写的方法或者继承的方法

 引用类型转换： 

　（1）向上类型转换（隐式/自动类型转换），是小类型到大类型的转换

             如：Dog dog=new Dog();Animal animal=dog;//正确，自动类型提升，向上类型转换

（2）向下类型转换（强制类型转换），是大类型到小类型的转换

             如：Dog dog1=(Dog)animal;//向下类型转换

（3）instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题

  Dog dog=new Dog();
  Animal animal=dog;
  Cat cat=(Cat)animal;  

编译时不会出错（按Cat类型进行编译），但运行时会报错，因为它开辟的是Dog类型的空间，而（无法将引用类型进行转换）无法将dog对象转换成Cat类型，并且此方法对程序的安全性有影响。此时应该利用instanceof和if语句结合使用，进行验证，以保证程序的安全性。
        //判断animal类中是否包含Cat类型的元素，若包含则进行转换，instanceof返回值为布尔类型。

if(animal instanceof Cat）{
    Cat cat=(Cat)animal;
}else{
    System.out.println("无法进行类型转换");
}

5、抽象类

（1）语法定义：

抽象类前使用abstract关键字修饰，则该类为抽象类。

（2）应用场景：

            a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法
            b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

  （3）作用：
             限制规定子类必须实现某些方法，但不关注实现细节。
  （4）使用规则：
　　     a、abstract定义抽象类
             b、abstract定义抽象方法，只有声明，不需要实现
             c、包含抽象方法的类是抽象类
             d、抽象类中可以包含普通的方法，也可以没有抽象方法
             e、抽象类不能直接创建，可以定义引用变量

public abstract class Telephone{
     public abstract void call();
     public abstract void message();
}

6、接口

　　（1）接口的概念

　　　　接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。

　　　　接口定义了某一批类所需要遵守的规范。

（2）接口定义

和类定义不同，定义接口使用interface关键字。

[修饰符] interface abstract 接口名 [extends 父接口1，父接口2……]
{
   //中括号中为可选项
   零个到多个常量定义……
   零个到多个抽象方法的定义
}

（3）接口就是用来被继承、被实现的，修饰符一般建议用public，不能使用private和protected修饰接口。

（4）接口中的属性是常量（public static final修饰），系统会自动加上

    （5）接口中的方法只能是抽象方法（public abstract修饰），系统会自动加上
    （6）使用接口：一个类可以实现一个或多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，可以通过实现多个接口作补充。

[修饰符] class 类名 extends 父类 implements 接口1，接口2……{
    类体部分//如果继承的是抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法
}

如果要继承父类，继承父类必须在实现接口之前
接口命名时首字母为I，以区分类名。

public interface IPlayGame{
     public void playGame();
}

public class Psp implements IPlayGame{
     public void playGame(){
           System.out.print("具有了玩游戏的功能");
     }
}

IPlayGame ip1 = new Psp();
ip2.playGame();