Java学习第七天

1.super不能调用静态区的东西

2.继承中的构造函数的特点：在创建子类对象时总是先执行父类的构造方法，再执行子类的构造方法
　　　　　　　　　　原因：系统自动的在子类的构造方法的第一行加入了super();意思是调用父类中空参的构造方法
3.为什么要先执行父类的构造方法？
　　　　因为子类继承父类，必然会继承父类的属性，先执行父类的构造方法可以利用父类中构造方法的给属性赋值的的代码,
　　这样子类的构造方法就不用再写给属性赋值的代码了。

4.继承父类的成员变量，在子类开辟内存空间时，会开辟继承父类成员变量的空间

5.构造函数是不能被继承的

6.this()和super()

this()必须在第一行，super()必须在第一行
在同一个构造方法中，this()和super()不能同时存在
调用构造方法在属性赋值前
例如：super();
this.name=name;

　　注意：每个类都要写上空参的构造方法

7.继承中成员变量的特点
　　成员变量同名，super区分
　　父类的成员变量为private,子类无权访问，只能使用父类提供的getXXX()方法来访问

8.重写：(前提条件:存在继承)
　　子类和父类有相同的行为，但是对该行为实现方式不同，所以子类需要重写
　　只要是创建子类对象执行的肯定是重写之后的方法(访问修饰符只可以往权限大的改)

9.继承中构造函数的特点：
　　系统自动在子类的构造方法中的第一行加入super()，意思是调用父类的空参构造方法
　　这样设计的目的是利用父类构造方法给属性赋值的语句，子类可以省略

10.final(最终) 关键字：修饰 类，方法，成员变量，局部变量
　　修饰类：不能有子类

　　修饰方法：不能被重写

　　修饰成员变量：(基本，引用) 变量的值不能被修改，对于引用类型来说就是不能再指向其它对象

　　修饰局部变量：包括函数参数，变量的值不能被修改

11.final补充

　　1 final用于修饰变量
　　　　final变量只能赋值一次，赋值的方式有三种：

　　　　1）声明变量时直接赋值；

　　　　2）非静态成员变量在{}块中赋值，静态成员变量在static{}块中赋值；

　　　　3）非静态成员变量在构造方法中赋值。

　　　　三种赋值方式的顺序是1）、2）、3），若有一种方式先行赋值了，则后面的方式就不能再赋值，否则就会编译错误。
　　2 final修饰类
　　　　final类不能被继承，因此不会有子类。final类中的方法不论是否有final修改，都是final的。

　　3 final修饰方法
　　　　final方法不能被override。若父类中的方法为final的，则子类不能override该方法，但可以调用该方法（父类的final方法）。

12.抽象类：在对子类提取共性的过程中，出现了无法实现的方法，因为子类对该方法有给自的实现方式
　　　　　所以父类就不实现这个方法了，这种方法就是抽象方法
　　　　　
13.特点：
　　1:不能创建对象
　　2：子类没有重写抽象方法，那么子类也是抽象类
　　abstract class 犬科
　　{
　　　　public abstract void 吼叫();//没有实现的方法 抽象
　　}

　　含有抽象方法的类就是抽象类，抽象类一定是父类
　　父类中含有抽象方法，子类没有重写该抽象方法，那么该子类也是抽象类
14.抽象类补充
　　1.抽象类一定是父类么
　　　　一定
　　2.抽象类和普通类的区别
　　　　共同点：都是类
　　　　不同点：抽象类不能创建对象，而普通类能创建对象
　　　　　　　　抽象类可以含有抽象方法，普通类不能含有抽象方法

　　3.抽象类有构造方法么
　　　　有构造方法，用于子类对象的创建

　　4.abstract和哪些关键字不能同时使用
　　　　1.final：final修饰的方法不能被重写，abstract修饰的抽象方法必须能被重写
　　　　2.static：static修饰的方法可以通过类名调用，abstract修饰的方法不能使用类名调用
　　　　3.private：private修饰的方法不能被重写，abstract修饰的抽象方法必须能被重写

　　5.抽象类一定含有抽象方法么
　　　　不一定，一般当希望这个类不能创建对象，就可以把类修饰为abstract
　　　　(是抽象类的不一定有抽象方法，有抽象方法的一定是抽象类)

15接口：
　　interface 接口名
　　{
　　　　//前面会默认添加修饰
　　　　public static final 成员变量------------------成为常量
　　　　public abstract 成员方法---------------------成为抽象方法
　　}

　　把接口看成特殊的类
　　解决了java单继承的弊端
　　接口是一种规范
　　接口是可以多实现的,实现多个接口时不会出现调用的不确定性，因为接口的方法都是抽象的方法，子类在实现接口时重写了抽象的方法
　　创建子类对象并调用重写的方法，很明确的是执行子类中重写的方法，而不是像多继承中无法识别继承的是那个类中的同名方法

interface inter
{
　　public static final int Num=88;
　　public abstract void show();

 6　　 //从jdk1.8开始，可以在接口中写实现了得方法，必须加defalut修饰
　　public default void fun()
　　{
　　　　System.out.println("hehe");
　　}
}

　　类和类之间是继承关系
　　类和接口之间是实现关系

　　通过继承可以得到同类型的父类中的内容
　　通过实现可以得到额外的功能
　　在继承的同时可以实现

　　class student extends Person implements inner
　　{}

　　接口与接口之间是继承关系

 

16.接口和抽象类中都可以定义抽象方法，怎么决定改用抽象类还是用接口

17.接口的作用：
　　接口是对外暴露的规则
　　接口是提高程序的扩展性
　　接口可以降低程序的耦合度(依赖关系)

18多态：事物的多种形态
　　class 动物{}
　　class 猫 extends 动物{}
　　把猫看成猫：猫 mao= new 猫();
　　把猫看成动物：动物 mao=new 猫();

　　父类类型的引用指向了子类类型的对象，形成多态

19.使用多态的前提：必须存在继承
　使用多态的弊端：只能使用父类的功能
　使用多态的优势：函数的参数使用父类类型，那么可以接收该父类的所有子类类型的对象，减少了很多函数的定义

20.装箱与拆箱

　　多态中的向上转型(装箱)：
　　　　父类引用中保存真实子类对象，称为向上转型(即多态核心概念)
　　　　注意：仅可调用Animal中所声明的属性和方法
　　多态中的向下转型(拆箱)：
　　　　将父类引用中的真实子类对象，强转回子类本身类型，称为向下转型
　　　　注意：只有转换回子类真实类型，才可调用子类独有的属性和方法

abstract class Animal{
　　public abstract void eat();
}
class Cat extends Animal{
　　public void eat(){
　　　　System.out.println("猫吃鱼");
　　}
　　public void catchMouse(){
　　　　System.out.println("猫抓耗子");
　　}
}
class Dog extends Animal{
　　public void eat(){
　　　　System.out.println("狗吃骨头");
　　}
　　public void kanHome(){
　　　　System.out.println("看家");
　　}
}
class Demo14
{
　　public static void main(String[] args) 
　　{
　　Animal mao =new Cat();//向上转型
　　//mao.eat();

　　//把Animal类型转成Cat类型 高---低
　　Cat xiaomao = (Cat)mao; //向下转型
　　//xiaomao.catchMouse();

　　Dog dog = new Dog();
　　chi(dog);

　　public static void chi(Animal dw)//Animal dw=new Cat()
　　{
　　　　dw.eat();

　　　　if(dw instanceof Cat){
　　　　　　Cat mao = (Cat)dw;
　　　　　　mao.catchMouse();
　　　　}

　　　　if(dw instanceof Dog){
　　　　　　Dog dog = (Dog)dw;
　　　　　　dog.kanHome();
　　　　}
　　}
}

21.Java中static方法为什么不能实现多态性

　　1.static关键字修饰的静态方法表示当前类的唯一实例,也就是说在整个java项目中这个方法是唯一的,既然是唯一的，只要编译成功并加载，就不存在先存储和后存储一说，不同类中的即使两个静态方法完全一样，也是两个方法，这和继承没有关系，当然继承也会继承静态方法(如果方法名不同的)，但调用静态方法和多态没关系。而同类的中两个静态方法完全一样，编译都通不过。

　　2.调用静态方法是用”类名点”的方式调用，用”对象点”来调用本身就是邪道。虽然能够使用。当然这么说也不够严谨，因为所有的类型类都是Class类的实例。

简单的，你可以当做，JVM会自动把对象的类型提出来，再用”类名点” 的方式 调用 静态方法 。

　　即使同个类中，不论是否是静态方法，其方法名相同，但()里面的参数不同（包括 ”参数类型”不同 或者 “参数个数“ 不同，或者两者都不同），那么这算不同的方法，而这涉及 方法重载
　　其中方法重载 又牵扯 自动类型转换 和 自动封装 的优先顺位 的问题。