学习路线:

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

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

一:封装

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 类名) {

类型转换代码;

}

例如:

public static synchronized OAuthConstant getInstance(){
if(instance == null)
instance = new OAuthConstant();
return instance;
}
*****对于抽象类,是只能用getInstance()方法,是不能new出来的。
总结:
getInstance这个方法在单例模式用的甚多,为了避免对内存造成浪费,直到需要实例化该类的时候才将其实例化,所以用getInstance来获取该对象,
至于其他时候,也就是为了简便而已,为了不让程序在实例化对象的时候,不用每次都用new关键字,索性提供一个instance方法,不必一执行这个类就
初始化,这样做到不浪费系统资源!
单例模式 可以防止 数据的冲突,节省内存空间

四:抽象类

1.抽象类语法语法:

public abstract class Demo {

}

2.抽象方法语法;

public abstract void abc();

3.规则:

  • 抽象类中可以声明成员变量、常量、成员方法、抽象方法,抽象类中不一定要有抽象方法;
  • 抽象类不能被实例化;对于抽象类,是只能用getInstance()方法,是不能new出来的。
  • 抽象类可以被继承;
  • 可以通过两种方式获得抽象类对象:父类引用指向子类对象、匿名内部类;
  • 子类必须重写抽象父类的所有抽象方法,或者是把子类也定义为抽象类;
  • 如果一个类继承的抽象父类还有上级抽象父类,那么子类中需要要重写所有抽象父类的所有抽象方法;
  • 抽象类也可以继承非抽象类,同时继承了父类的所有非私有的属性和方法;
  • 含有抽象方法的类,一定是抽象类;
  • .构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法;

五:接口

1.定义:

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

interface关键字

2.语法:

if (对象名 instanceof 类名) {

类型转换代码;

}

3.接口的声明:

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

常量声明

方法声明

}

注意:

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

4.接口的实现:

1.定义:

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

类体

}

2.作用:

接口把方法的特征和实现分开,这种分割体现在接口常常代表一个角色。他包装了这个角色相关的操作和属性,而实现这个接口的类就是扮演了这个角色的演员,一个角色由不同的演员来演,而不同的演员之间除了扮演一个共同的角色之外,并不要求他的共同之处。

3.注意

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

4.接口特性:
4.1.接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
4.2.接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
4.3.接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。

实例:

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--封装,继承,多态的更多相关文章

  1. Java基础之理解封装,继承,多态三大特性

    目录 封装 继承 多态 封装 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据.对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法. 代码理解 publ ...

  2. Java基础学习笔记八 Java基础语法之接口和多态

    接口 接口概念 接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”.接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成.这样将功能的定义 ...

  3. -1-2 java 面向对象基本概念 封装继承多态 变量 this super static 静态变量 匿名对象 值传递 初始化过程 代码块 final关键字 抽象类 接口 区别 多态 包 访问权限 内部类 匿名内部类 == 与 equal

    java是纯粹的面向对象的语言 也就是万事万物皆是对象 程序是对象的集合,他们通过发送消息来相互通信 每个对象都有自己的由其他的对象所构建的存储,也就是对象可以包含对象 每个对象都有它的类型  也就是 ...

  4. Java基础语法07-面向对象-多态

    抽象类 抽象方法 : 没有方法体的方法. 抽象类:被abstract所修饰的类. 抽象类的语法格式: [权限修饰符] abstract class 类名{ }[权限修饰符] abstract clas ...

  5. 深入理解Java面向对象三大特性 封装 继承 多态

    1.封装 封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系 为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类 ...

  6. JAVA的三大特征 封装继承多态- 简单总结

    简单总结一下 封装-即从很多类的抽取相同的代码 写在一个类里. 好处是 代码的重用,安全. 继承-减少代码的书写. 其好处也是 代码的重用. 多态- 把不同的子类对象都当作父类来看,可以屏蔽不同子类对 ...

  7. Java入门教程九(封装继承多态)

    封装 封装就是将对象的属性和方法相结合,通过方法将对象的属性和实现细节保护起来,实现对象的属性隐藏.做法就是:修改属性的可见性来限制对属性的访问,并为每个属性创建一对取值(getter)方法和赋值(s ...

  8. Java三大特征:封装 继承 多态

    内部类:成员内部类.静态内部类.方法内部类.匿名内部类. 内部类:定义在另外一个类里面的类,与之对应,包含内部类的外部类被称为外部类. 内部类的作用:(1)内部类提供了更好的封装,可以把内部类隐藏在外 ...

  9. Java基础语法Day_08(继承、抽象)

    第1节 继承 day09_01_继承的概述 day09_02_继承的格式 day09_03_继承中成员变量的访问特点 day09_04_区分子类方法中重名的三种变量 day09_05_继承中成员方法的 ...

随机推荐

  1. loadrunner:文本检查点web_reg_find和web_find两个函数的区别

    web_reg_find是先注册(register)后查找的:使用时将它放在请求语句的前面. 而web_find是查找前面的请求结果:使用时将它放在请求语句的后面. 另二者的参数也完成不一样的,web ...

  2. C#创建任务计划

    因写的调用DiskPart程序是要用管理员身份运行的,这样每次开机检查都弹个框出来确认肯定不行.搜了下,似乎也只是使用任务计划程序运行来绕过UAC提升权限比较靠谱,网上的都是添加到计算机启动的,不是指 ...

  3. hdu5792 World is Exploding(多校第五场)树状数组求逆序对 离散化

    题目地址:http://acm.hdu.edu.cn/showproblem.php?pid=5792 题目描述:给你n个值,每个值用A[i]表示,然后问你能否找到多少组(a,b,c,d)四个编号,四 ...

  4. k8s集群之master节点部署

    apiserver的部署 api-server的部署脚本 [root@mast-1 k8s]# cat apiserver.sh #!/bin/bash MASTER_ADDRESS=$1 主节点IP ...

  5. integer to roman leetcode c++实现

    Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 t ...

  6. JavaSE-28 hashCode()方法、equals()方法和==相关概念

    概述 Java中,Object类是所有类的基类:如果一个类没有明确继承其他已定义的类,则默认继承Object类. Object类提供了以下方法,对于其他方法,请参考前期专题描述. hashCode() ...

  7. Centos7中yum安装jdk及配置环境变量

    系统版本 [root@localhost ~]# cat /etc/redhat-release CentOS Linux release 7.4.1708 (Core) #安装之前先查看一下有无系统 ...

  8. python基础(一)—— 核心数据类型

    Hello World程序 [root@mysql ~]# python3 Python 3.6.5 (default, Jul  8 2018, 11:41:23) [GCC 4.4.7 20120 ...

  9. 04 Beautiful Soup

    Beautiful Soup 简介 简单来说,Beautiful Soup是python的一个库,最主要的功能是从网页抓取数据.官方解释如下: ''' Beautiful Soup提供一些简单的.py ...

  10. tomcat——大致简介和执行过程

    jsp简介 JSP: JAVA Server Page 使用JAVA语言编写的一种在服务器运行的动态页面 JSP = JAVA + HTML JSP 的执行过程 1: 翻译阶段 把JSP源文件翻译成 ...