学习路线：

未封装==>封装==>继承==>多态==》抽象类

首先还是那句话，万物皆对象，对象有行为和属性。

一：封装

1.封装的概念：

信息隐蔽和对象的属性及操作结合成一个独立的系统单位。

私有的属性，公开的方法。

达到数据隐藏和保护的目的。

2.封装的步骤：

*声明私有（private）的属性；

*声明公开的（public）geter,seter方法；

二：继承

1.继承的概念：

已有类创建新类的过程。Java中的继承是单继承，可以实现多层继承，继承的关键字extends

2.继承的语法：

【访问控制修饰符】 class 子类名 extend 父类名{

数据成员；

成员方法；

}

3.规则：

• 子类继承父类非私有的所有属性和方法，不能继承父类的构造方法；
• 实例化子类对象的步骤：先执行父类的构造方法，再执行子类的构造方法；

4.数据成员的隐藏：

子类继承父类，但子类中重新定义一个与父类中已定义的数据成员名完全相同的数据成员。默认操作是他引用自己定义的。

例如：

package com.num2.lianxi;

public class project1 {
    int a=10;  父类中定义了数据成员a
}
class Project2 extends project1{
    int a=20;  子类中重新定义数据成员a
}
 class Project3{
    public static void main(String[] args){
    Project2 p=new Project2();
    System.out.println(p.a);
    }
}

那门问题来了，在这种情况下怎样访问子类对象中从父类继承而来的成员变量，有两种方法解决：

4.1.强制类型转换：

 System.out.println(（project1）p.a);

4.2.super引用：

5.成员方法的覆盖:

定义：子类可以重新定义与父类同名的成员方法（方法名相同，参数个数，类型，顺序相同，返回值类型相同，但是参数名字可以不同）。实现对父类方法的覆盖。

注意：构造方法之间不存在方法的覆盖。

6.子类的构造方法

注意：

*在一个类没有显式定义自己的构造方法的时候，编译器自动为他提供一个无参构造方法。

*如果父类不存在无参构造方法，则子类使用关键字super手动调用父类的有参构造方法。且此语句必须作为子类构造方法的第一条可执行语句。

*构造函数以派生的顺序被调用。

7.this关键字和super关键字：

7.1 this关键字

this指当前对象（当前类的一个实例），用法：

• 当局部变量名和实例变量名同名时，使用this.变量名来表示实例变量；
• this()表示当前类的构造方法，只能在构造方法中使用该写法，并且是写在构造方法内的第一行。
• 返回调用当前方法的对象的引用。

  public class Project1 {
    private int i=120;
    public Project1 inc(){
        i++;
        return this;   //this表示project1类的实例
    }
     public void print(){
        System.out.println("i="+i);
     }
     public static void main(String[] args){
        Project1 c=new Project1();
        c.inc().inc().print();
     }
  }

   

• 访问当前对象的数据成员和成员方法。
• 使用this调用同类的其他构造方法。

7.2 super关键字

super指当前对象的直接父类对象，用法：

• 在子类中可以通过super调用其父类的方法，属性和构造方法。
• 访问从父类继承而来的数据成员和成员方法

   class Project1 {   //使用super访问父类成员
      int x = 1;
      int y = 2;
  
      void Printme() {
          System.out.println("x=" + x + " y=" + y);
          System.out.println("class name:"+ this.getClass().getName());
      }
  }
    class Sub extends Project1{
        int x=10;
        int z=1;
        void Printme(){
            z=super.x+3;//引用在父类中定义的数据成员
            super.Printme();//引用父类中定义的成员方法
            System.out.println("z="+z+" x="+x);
            System.out.println("i am an :" +this.getClass().getName());
        }
      }
      class TestSuper1 {
        public static void main(String[] args){
            project1 b=new project1();
            b.Printme();
            System.out.println("12/*/*/*/*");
            Sub s=new Sub();
            s.Printme();
        }
      }

  **子类对象s调用方法Printme()时，用到了父类继承而来数据成员和方法成员。

• 使用super访问父类的构造方法

三:  多态（对象存在多种形态）

1实现的必要条件：

• 继承
• 重写
• 父类引用指向子类对象

2.体现在两方面：引用多态和方法多态

• 方法重载实现的编译时多态（静态多态性）
• 方法覆盖结合变量多态实现的运行时多态（动态多态性）

3.instance关键字：来解决引用对象的类型。

语法：

if (对象名 instanceof 类名) {

类型转换代码；

}

四:抽象类

1.抽象类语法语法：

public abstract class Demo {

}

2.抽象方法语法;

public abstract void abc();

3.规则：

含有抽象方法的类，一定是抽象类；

• 抽象类中可以声明成员变量、常量、成员方法、抽象方法，抽象类中不一定要有抽象方法；
• 抽象类不能被实例化；
• 抽象类可以被继承；
• 可以通过两种方式获得抽象类对象：父类引用指向子类对象、匿名内部类；
• 子类必须重写抽象父类的所有抽象方法，或者是把子类也定义为抽象类；
• 如果一个类继承的抽象父类还有上级抽象父类，那么子类中需要要重写所有抽象父类的所有抽象方法；
• 抽象类也可以继承非抽象类，同时继承了父类的所有非私有的属性和方法；

 五：接口

1.定义：

接口是用来约束类的。是方法声明和常量值定义的集合。java中实现多重继承的重要手段。

interface关键字

2.语法：

if (对象名 instanceof 类名) {

类型转换代码；

}

3.接口的声明：

【访问控制符】 interface 接口名 【extends 父接口列表】{

常量声明

方法声明

}

注意：

• 接口中的成员方法都是抽象方法，而抽象方法需要在实现接口的类中实现。
• 接口无构造方法，不能被实例化
• 一个接口可以有一个及以上父接口

4.接口的实现：

【访问控制符】 class 类名 【extends 父类名】 implements 接口列表{

类体

}

注意

• 接口使用interface关键字修饰；
• 接口是一个完全抽象的抽象类；
• 接口中没有构造方法；
• 接口不能被实例化对象；
• 接口中可以声明静态常量、抽象方法、静态方法；
• 接口中不能声明实例方法，声明抽象方法时，不能使用static关键字修饰；
• 声明接口语句中，默认含有abstract关键字，抽象方法中也默认含有abstract关键字；
• 接口可以被实现，使用implements关键字，一个类实现一个接口，必须重写该接口中所有的抽象方法；
• 一个类可以实现多个接口，每个接口名用英文的逗号隔开，该类中必须重写所有已实现接口中的抽象方法；
• 接口可以继承接口，接口与接口间是多继承关系，接口不能继承类；

实例：

public interface Flyable {//此接口表示飞行能力
    void fly();
}
interface Talkable{//此接口表示说话能力
    void talk();
}
class Parrot implements Flyable,Talkable {
    public void fly(){
     System.out.println("Flying like a parrot...");
    }
    public void talk(){
        System.out.println("hello! i am a parrot!");
    }
}
class Swallow implements Flyable{
    public void fly(){
        System.out.println("Flying like a Swallow");
    }
}
public  class TestInterface{
    public static void main(String[] args){
      Parrot pa=new Parrot();
      Swallow sw=new Swallow();
      enFly(pa);
      enFly(sw);
      enTalk(pa);
    }
    public static void enFly(Flyable fa) {
        fa.fly();
    }
    public static void enTalk(Talkable ta) {
        ta.talk();
    }
}

java基础语法4--封装，继承，多态

原文：https://www.cnblogs.com/lxx99/p/10864710.html