java的三大特性--封装,继承,多态
用三个类父类,子类,测试类
测试java的三大特性:封装,继承,多态:
父类:
package oop;
/** 面向对象的三大特性:封装,继承,多态 */
public class Character {
/*
* 封装:万物皆对象,我们把这些对象封装起来组成数据类型,那数据类型包括 属性和方法
*/
/*
* 类中的属性隐藏,提供公开的方法 修辞符 类型 属性名称; (可选:将赋值)
*/
private String name;
private int age;
private final long ID;
/* 类需要实例化,就提供构造方法 */
public Character(long ID) {
this.ID = ID;
System.out.println("父类的构造方法,有参的");
}
/* 无参的构造函数,自己不定义系统也会定义一个无参无实现的工作函数 */
public Character() {
this.ID = 1000009489;
System.out.println("父类的构造方法,无参的");
}
static{
System.out.println("父类的静态代码块");
}
{
System.out.println("父类的实例代码块");
}
/* 为隐藏的属性提供公开的方法seter和getter */
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public long getID() {
return ID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/*
* 定义方法 修辞符 返回类型 方法名(参数列表){} 参数:类型 参数名
*/
public void method1() {
System.out.println("父类的method1()方法");
}
private void method2(int num, String name) {
System.out.println("父类的method2(int num, String name)方法");
}
public void method3(String name) {
System.out.println("父类的method3(String name)方法");
}
/*
* 方法的重载: 同一个类,同名,不同参数
*/
public void m1() {
System.out.println("父类的m1()方法");
}
/*
* public boolean m1(){ error }
*/
/*
* private void m1(){ error
* }
*/
public void m1(String name) {
System.out.println("父类的m1(String name)方法");
}
/*public boolean m1(String name) {
error
}*/
public void m1(String name, int age) {
System.out.println("父类的m1(String name, int age)方法");
}
public boolean m1(int age) {
System.out.println("父类的m1(int age)方法");
return true;
}
}
子类:
package oop;
/**
* 继承:子类继承于父类,继承了方法和属性 语法: 修辞符 class 子类名 extends 父类名{}
*/
public class SendCharacter extends Character {
private String sendName;
public String getSendName() {
return sendName;
}
static{
System.out.println("子类的静态代码块");
}
{
System.out.println("子类是实例代码块");
}
public void setSendName(String sendName) {
this.sendName = sendName;
}
/* 子类的构造方法一定要调用父类的构造方法 */
public SendCharacter(long ID) {
super(ID);// 调用父类的构造方法
System.out.println("子类的有参构造方法");
}
public SendCharacter() {
super();// 调用父类的构造方法
System.out.println("子类的无参构造方法");
}
/*方法的覆盖:
* 1.同没
* 2.同参
* 3.父子类之间
* 4.子类的修辞符不能比父类的更封闭
* 5.子类抛出的异常不能比父类更宽泛
* */
public void m1(){
System.out.println("子类覆盖的m1()方法");
}
private void method2(int num, String name) {
System.out.println("子类覆盖的method2(int num, String name)方法");
}
public void method3(String name) {
System.out.println("子类覆盖的method3(String name)方法");
}
/**自己写的方法:*/
public void subM1(){
System.out.println("子类自己的subM1()方法");
}
}
测试类:
package oop;
public class Test {
public static void main(String[] args) {
System.out.println("main of start");
//父类对象
Character c=new Character();
//父类对象,只能调用父类的方法
c.m1();
c.m1(10);
//子类对象,父类,子类的方法都能调用
SendCharacter sc=new SendCharacter();
sc.subM1();
//多态:--把子类对象当父类来看
Character cs=new SendCharacter();
cs.m1();
cs.m1(20);
//cs.subM1();//error
/*
*
* 1.如果我们把子类的对象当成父类来看,那我们就只能访问
* 父类中已有的方法和属性
* 2.如果子类把父类的方法覆盖了,再把子类当成父类来看,去
* 调用方法调用的是覆盖后的方法
*
* 主观认为----------客观存在
*
* 编译时类型(编译器)--------运行时类型(JVM)
* */
System.out.println("main of end");
}
//运行结果如下:
/*main of start
父类的静态代码块
父类的实例代码块
父类的构造方法,无参的
父类的m1()方法
父类的m1(int age)方法
子类的静态代码块
父类的实例代码块
父类的构造方法,无参的
子类是实例代码块
子类的无参构造方法
子类自己的subM1()方法
父类的实例代码块
父类的构造方法,无参的
子类是实例代码块
子类的无参构造方法
子类覆盖的m1()方法
父类的m1(int age)方法
main of end*/
}
- java笔记—封装、继承、多态[面向对象的三大特性]
- Java三大特性——继承,封装和多态
- Java的面向对象的三大特性 封装 继承 多态
- Java学习第六课--面向对象的三大特性(封装、继承和多态)
- 关于java三大特性 封装 继承 多态
- 深入理解Java面向对象三大特性 封装 继承 多态
- Java的三大特性:封装、继承、多态
- java的三大特性--封装,继承,多态
- Java三大特性---封装,继承,多态
- JAVA三大特性—封装、继承、多态
- Java — 面向对象的三大特性(封装、继承、多态)
- Java中的三大特性:封装、继承、多态
- Java语言的三大特性即是:封装、继承、多态
- 初步理解Java的三大特性——封装、继承和多态
- Java之面向对象的三大特性:封装,继承,多态讲解
- 【java学习】面向对象三大特性:封装,继承,多态
- java 面向对象三大特性(封装,继承,多态)以及抽象、接口的介绍
- Java面向对象的三大特性——封装,继承,多态
- Java的三大特性(继承、封装、多态)
- Java三大特性之封装继承多态