java基础知识点二(上)

继承：

当多个类中存在相同属性和行为时，将这些内容抽取到单独的一个类中。其他类继承这个单独的类即可。

继承的出现让类与类之间产生了关系，提供了多态的前提。

多个类可以称为子类，单独这个类称为父类或者超类。

子类可以直接访问父类中的非私有的属性和行为。

要访问父类的私有属性必须用共有的set和get方法

继承的出现提高了代码的复用性。

子类不能降低父类继承过来的方法的权限

 

Java只能单继承，不支持多继承

class SumDemo extends Demo{}

class SumDemo extends Demo,Sum{}

但java可以多层继承

         classA{}

         class B extends A{}

         class C extends B{}

注意:

         不要仅为了获取其他类中某个功能而去继承。

必须是类与类之间有所属（is a）关系才可以继承。

 

super关键字：

         super和this的用法相同。

         this代表本类引用，super代表父类引用。

         当子父类出现同名成员，可以用super进行区分。

         子类调用父类的构造函数时，可以用super调用（必须放在第一行）。

 

子类实例化过程：

         子类中所有的构造函数默认都会访问父类中空参数的构造函数，因为每一个构造函数的第一行都有一条默认的语句super();

子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。

当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

 

函数覆盖：

         当子类需要父类的功能，而子类需要自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

         子类中出现与父类一模一样的方法时，当子类调用该函数，会运行子类函数的内容，出现覆盖操作，也称为重写或者复写，例：

         public class Singleton {

   public static void main(String[] args) {

      new Son().show();

   }

}

class Father{

   void show(){

      System.out.println("父类");

   }

}

class Son extends Father{

   void show(){

      System.out.println("子类");

   }

}

父类中的私有方法不可以被覆盖。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名

获取。

注意：

覆盖时，子类方法权限一定要大于等于父类方法权限
（从private到default不算是覆写）

子类与父类同名属性也会出现覆盖

静态只能覆盖静态。

 

final（最终）：

         当有些类或值我们不想被子类使用时可以使用final。

         final可以修饰类，方法，变量。

被final修饰的类不能被继承，被final修饰的函数不能被覆盖，被final修饰的变量是一个常量，只能赋值一次。

例：

         public class Singleton {

   public static void main(String[] args) {

     

   }

 

}

final class Father{

   public static final double PI=3.1415926;//相当于一个全局变量

   final int x=3;

   void show(){

      x=5;//被final修饰的变量就变成常量了，所以不能再赋值

      System.out.println("父类");

   }

}

class Son extends Father{//会报错，因为父类被final修饰

   void show(){

      System.out.println("子类");

   }

}

 

内部类只能访问被final修饰的局部变量。

将内部写在方法中，又想要访问方法中的参数，那么参数必须是final定义的(jdk1.8就可以不写final)

public class Singleton {

   public static void main(String[] args) {

      new Outer().fun(1); //传入参数给temp

   }

}

class Outer{

   public void fun(final int temp){

      class Inner{

         public void print(){

            System.out.println("方法中的参数"+temp);

         }

      }

      new Inner().print();

   }

}

 

抽象类：

多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取'了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

 

抽象就是从多个事物中将共性的，本质的内容抽取出来。

例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

 

Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

 

抽象类中有构造函数

 

抽象类和抽象方法必须用abstract来修饰。

抽象方法只有方法声明，没有方法体，定义在抽象类中。

抽象类不能被实例化（也就是不能new创建对象），因为：

1.      抽象类是具体事物抽取，本身是不具体的，没有对应的实例。

2.      抽象类即使创建了对象，调用抽象方法也没有意义了。

子类需要覆盖抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

例：

public class AbstractDemo {

   public static void main(String[] args) {

      new Student().fun();

   }

}

abstract class Person{

   public abstract void fun();

}

 

class Student extends Person{

   public void fun(){

      System.out.println("java");

   }

}

抽象类问题：

抽象关键字abstract不可以和哪些关键字共存？
（final，抽象方法不能是private的）

抽象类中可不可以没有抽象方法？
可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。

 

总结：抽象类和普通类比较，除了多了一个抽象方法之外和不能实例之外没有什么不同。

 

接口：

         当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用接口interface来代替。

         接口中的成员修饰符是固定的（只能有这个两种元素，可以省略不写）。

         成员常量：     publicstatic final

         成员函数：     publicabstract

        

         接口也不能创建对象，因为有抽象方法。需要被子类实现（implements），并且子类需把抽象方法全部覆盖，否则子类是一个抽象类。

         接口的出现将“多继承”通过另外一种形式体现出来，即“多实现”。

 

         接口的特点：

        

         接口是对外暴露的规则。

接口是程序的功能扩展。

接口可以用来多实现。

类与接口之间是实现关系，而且类可以

继承一个类的同时实现多个接口。

接口与接口之间可以有继承关系。

类可以同时继承抽象类和接口

例：

         public class InterfaceDemo {

   public static void main(String[] args) {

      // TODO Auto-generated method stub

      new Inter().show();

   }

 

}

interface Test{

   public static final int NUM=1;

   int NUM2=2;//这样和上面是相同的，系统会自动补修饰符，最好写全，容易阅读，知道它是全局常量。

   public abstract void show();

}

class Inter implements Test{

   @Override

   public void show() {

      // TODO Auto-generated method stub

      System.out.println("java"+NUM+" "+NUM2+" "+(NUM+NUM2));

   }

}

 

多态：

   事物存在的多种体现形态。

   多态的前提：  必须是类与类之间有关系，要么继承，要么实现。

   多态的好处：  多态的出现大大的提高了程序的扩展性。

   多态的体现：  父类的引用指向了自己的子类对象，父类的引用也可以接受自己的子类对象。

   例：猫这个对象是猫类型

      猫 x = new 猫();

      同时猫也是动物中的一种

      动物 y = new 猫();

   动物是猫和狗以及其他小动物中抽取出来的父类型。

   多态的弊端：  只能使用父类的引用访问父类中的成员。

 

   当想使用父类调用子类特有的方法时，需要转型。

   动物 y = new 猫();  //向下转型要先向上转型

猫x = (猫)y;      //多态自始至终都是子类对象在变化,多态中向下转型最好是先用instanceof判断下类型

例：

   public class PolymorphicDemo {

   public static void main(String[] args) {

      // TODO Auto-generated method stub

      factory(new Cat());

      factory(new Dog());

   }

   public static void factory(Animal a){

      a.eat();//多态，使用父类调用公共的吃方法

      if (a instanceof Cat) {//判断类型

         Cat c = (Cat) a;//向下转型

         c.catchMouse();//调用子类特有的方法

      }

      if (a instanceof Dog) {

         Dog d = (Dog) a;

         d.mindHouse();

      }

   }

}

abstract class Animal{

   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 mindHouse(){

      System.out.println("看家");

   }

}

 

类设计的注意事项：

类的设计主要是父类的设计。

子类永远别去继承一个已经完全实现好的类，因为一旦发生向上转型，所调用的方法一定是被子类覆盖过的方法，所以只会继承抽象类或者是接口。

 

抽象类和接口的区别：

抽象类是一个模板

接口是一个标准