java复习11/28---第五章

tostring

所有的根类是Object类，Object类有toString( )方法，所有的类中都有toString( )方法

 @Override
    public String toString() {
        return "red{" +
                "a=" + a +
                ", b=" + b +
                '}';
    }

注意renturn 后面格式，没有括号

第五章

类里面有变量—体现成员封装

继承

在Java中，用extends创建继承关系
class Car extends Vehicle
{
// 类体
}
没有extends，默认父类为java.lang.Object
只能有一个父类，即单继承
继承就是子类继承父类的成员变量和方法作为自己的成员变量和方法

子类和父类在同一包中的继承性：子类继承父类中非private变量和方法，
且继承的变量和方法的访问权限不变
子类和父类不在同一包中的继承性：
子类继承父类中protected、public变量和方法，
且继承的变量和方法的访问权限不变；
但子类不能继承父类的友好成员，improt了也不行（友好成员就是什么都不写直接class那种）
如果没有import chaxun.color;直接报错，
整个父类也必须是public class color ，没有public报错（不是一个包）

调用子类构造方法
总是先调用父类的构造方法，若未指明，则调用父类无参构造方法

类中定义了与父类同名的方法
方法重写：子类中定义的方法，其名字、返回类型、参数个数和类型与继承的方法完全相同【例5-4】
方法重载：子类中定义的方法与继承的方法名字相同，但参数不同（个数、类型、顺序不同）【例5-5】

this

作用：
在子类的构造方法中
使用super调用父类的构造方法
在子类方法中
使用super调用被子类隐藏的父类的
成员变量和方法？？没看

子类的构造函数写法
blue(int c,int deep)
{
super(deep);
this.c=c;

}
如果是super(),对应父类的 无参构造

final

关键字final:
final类不能被继承
final方法不能被重写
final成员常量，值不能改变

上转型对象

假设B是A的子类或间接子类
A a；
a=new B();//b是子类

那么，就称对象a是子类对象的上转型对象
对象的上转型对象的实体是子类负责创建的，但上转型对象会失去原对象的一些属性和功能：
上转型对象不能操作子类声明定义的成员变量和子类声明定义的方法
上转型对象可以操作子类继承的成员变量和隐藏的成员变量，可以使用子类继承或重写的方法
上转型对象不能操作子类新增的方法和成员变量

多态

利用*** 方法重写 和 上转型对象 ***

父类有多个子类，且子类都重写了父类中的某个方法，不同子类的上转型对象调用同一重写方法可能产生不同的行为

例子：
猫狗分别继承动物类，用 父类 obj=new 子类();创建上转型对像，则这个父类对象在调用被重写的函数cry时有不同的输出；
正常的猫类对象不能调用狗的函数

public class animlas {
    void cry()
    {
        System.out.println("动物叫");
    }
    void eat()
    {
        System.out.println("eat..");
    }
}
class dog extends  animlas{
    void cry()
    {
        System.out.println("汪汪汪");
    }
    void kanmen()
    {
        System.out.println("狗在看门");
    }
}
class cat extends  animlas{
    void cry()
    {
        System.out.println("miaomiaomiao");
    }
}
class test{
    public static void main(String[] args) {
        animlas obj1=new cat();
        obj1.cry();
        animlas obj2=new dog();
        obj2.cry();
        cat obj3=new cat();
        obj3.eat();

    }
}

抽象类

abstract class 类名
拼写

abstract类可以有abstract方法，只允许声明，而不允许实现；也可以有非abstract方法抽象类可以没有抽象 方法，但抽象方法必须在抽象类中
不能用new运算符创建对象，但可做上转型对象
抽象类的非抽象子类必须重写其所有抽象方法

接口

interface
implement
class TV implements ShowMessage
拼写
例子：
接口中的方法不能有定义（方法体）“；”直接跟在
方法声明后

public interface Doable
{
   public static final int A_CONST=100;
   void doThis();
   int doThat();
   void doThis2 (float value, char ch);
   boolean doTheOther (int num);
}

接口中的方法默认是public abstract类型
接口中的常量默认是public static final类型
接口比抽象类还抽象，不能被直接实例化
Java中的类只能单继承，但可以实现多个接口，但必须实现所有接口的所有方法

接口的多态

就是两个不同类分别实现一个接口，但是重写了方法，
在测试类中 j接口名 obj=new 类名1/2（）

interface ShowMessage{
    void showTradeMark();
}
lass TV implements ShowMessage{
    public void showTradeMark(){
         System.out.println("我是电视机");}
}
class PC implements ShowMessage{
     public void showTradeMark(){
         System.out.println("我是电脑"); }
}
public class Example5_12{
    public static void main(String args[]){
         ShowMessage sm;                 
         sm=new TV();                    
         sm.showTradeMark();              
         sm=new PC();                    
         sm.showTradeMark();              
    } 
}

接口和抽象类区别

接口中只可以有常量，不能有变量；而abstract类中即可以有常量也可以有变量
abstract类中也可以有非abstract方法，接口不可以

内部类

没看

匿名类

没有自己的名字
输出结果为：在匿名类内部
class 和父类 平行的 类{
public void 方法1（）{
父类 obj=new 父类（）{
pulic void 父类方法（）{
}
obj.父类方法（）；//在方法1中由obj调用父类方法

package chaxun;

class Polygon {
    public void display() {
        System.out.println("在 Polygon 类内部");
    }
}

class AnonymousDemo {
    public void createClass() {

        // 创建的匿名类继承了 Polygon 类
        Polygon p1 = new Polygon() {
            public void display() {
                System.out.println("在匿名类内部。");
            }
        };
        p1.display();
    }
}

class Main {
    public static void main(String[] args) {
        AnonymousDemo an = new AnonymousDemo();
        an.createClass();
    }
}