常熟住房和城乡建设局网站,外贸公司名字大全洋气,网站建设栏目内容,在线设计平台saas的市场份额这篇博客将会涉及到#xff1a;
继承的概念和实现super关键字方法重写—OverrideObject常见方法
继承的概念#xff1a;
生活中#xff0c;继承的概念随处可见#xff0c;继承需要符合的关系#xff1a;is-a#xff1b;父类更通用、子类更特殊更具体。就比如说#x…这篇博客将会涉及到
继承的概念和实现super关键字方法重写—OverrideObject常见方法
继承的概念
生活中继承的概念随处可见继承需要符合的关系is-a父类更通用、子类更特殊更具体。就比如说动物是一个类那么它的子类可以是食草动物、食肉动物。
对于java语言来说继承背后的思想就是基于已存在的类来构建新类当从已存在类继承时就重用了它的方法和属性还可以添加新的方法和属性来定制新类以应付需求。约定 从其他类导出的类叫做子类被导出的类叫做父类。在java中除了Object类之外所有类都是子类都只有唯一父类。就是在创建类的时候如果不写类继承自哪一个类系统会默认的认为是Object的子类通过下图方法可查看一个类继承的父类 继承在OOP中不可或缺不写继承自哪一个类会默认继承Object类创建一个类时总是在继承继承的意义 代码重用、体现不同的抽象层次。父子类关系 父类更抽象更一般、子类更具体更特殊。在java语言中用extends 关键字来表示一个类继承了另外一个类如下
public class Teacher extends Person{
}extends使用示例
package fhn.demo.java;
class Person{String name;String address;public void eat(){System.out.println(人吃饭);}public void drink(){System.out.println(人喝水);}
}
class Student extends Person{String address;float score;void goToSchool(){System.out.println(去上学);}
}
public class Test {public static void main(String[] args) {Person pnew Person();Student snew Student();p.name人;p.eat();p.drink();s.name学生;s.eat();s.drink();s.goToSchool();}
}super关键字
super关键字的特点
super和this关键字的特点类似super代表的是父类对象的引用当子父类的成员出现同名时可以通过super来区分子类构造方法中通过super关键字调用父类的构造方法在子类构造方法中默认都是调用了父类的构造方法super()这个是无参数的当想调用父类的构造方法是有参数的时候就要自己在子类的第一行输入super(参数)来调用父类的构造方法。强调 当构造一个子类对象的时候一定会先调用父类的构造方法来初始化父类的字段。调用父类构造方法的语句必须是子类构造方法中的第一条指令。注意 子类只能调用父类的构造方法来初始化参数当然也可以在自己的构造方法中添加一些父类构造方法没有的语句java继承之私有权限父类的私有属性和私有方法不会被子类继承但是可以通过父类的公有方法来间接访问父类的私有属性
class Person{String name;String address;//public Person(){};//无参构造方法当不写带参数的构造方法系统会默认的添加无参构造方法public Person(String name,String adress) {//父类的构造方法this.namename;this.addressadress;System.out.println(父类构造方法被调用);}public void eat(){System.out.println(父类的人吃饭);}public void drink(){System.out.println(父类的人喝水);}
}
class Student extends Person{float score;public Student(String name,String adress) {//子类的构造方法super(name,adress);//在子类的构造方法里面通过super调用父类的构造方法//调用父类构造方法的语句必须是子类构造方法中的第一条指令。/** this.namename;* this.adressadress;//这种写法不可以当父类里面存在无参构造方法时* //子类需要通过super关键字来调用父类的构造方法在自己的构造方法里面进行参数的初始化* */System.out.println(子类构造方法被调用);//当然也可以在自己的构造方法中添加一些父类构造方法没有的语句}void goToSchool(){System.out.println(去上学);}public void eat(){super.eat();//当子父类的成员出现同名时可以通过super来区分System.out.println(子类的人吃饭);}
}
public class Main {public static void main(String[] args) {Person pnew Person(你们,北京);Student snew Student(我们,河北);//当构造一个子类对象的时候一定会先调用父类的构造方法来初始化父类的字段p.eat();p.drink();s.eat();s.drink();s.goToSchool();}
}Object常见方法
java中所有的类都可以直接或间接继承自java.lang.Object类可以说Object是java中所有类的祖先即根类。java任何类中都继承了Object类中的方法主要有toString()、equals()、hashcode()、clone()、getClass()、finalize()String toString(): 返回该对象的字符串描述信息。默认输出格式是类名[字段值字段值…]。只要对象与一个字符串通过“”连接系统就会自动调用toString获得对象的字符串描述符。常被改写可以根据用户的需求对其进行重写。Boolean equals(): OBject类原始功能是实现判断两个对象是否具有相同的引用要求判断两个对象状态的相等性。
class Person{String name;String address;//public Person(){};//无参构造方法当不写带参数的构造方法系统会默认的添加无参构造方法public Person(String name,String adress) {//父类的构造方法this.namename;this.addressadress;System.out.println(父类构造方法被调用);}public String toString() {//在子类里面对Object类父类toString方法进行重写//默认返回父亲的toStringreturn super.toString();return person message:nameaddress;}public boolean equals(Object arg0) {//对equals进行重写判断两个类里面的内容知否一致// TODO Auto-generated method stub//return super.equals(arg0);Person p(Person) arg0;if(this.namep.namethis.addressp.address)//java中可用表示两个字符串是否相等在C语言中用strcmpreturn true;elsereturn false;}
}
public class Main {public static void main(String[] args) {Person pnew Person(你们,北京);/*不对toString方法进行重写* System.out.println(p.toString());//输出Person659e0bfd----Person类名、659e0bfd是类的内存地址//若果有包名还会将包名打印出来//默认打印这个对象的地址和相关信息返回值是字符串类型*///对toSting方法进行重写System.out.println(p.toString());//输出--你们北京Person p2new Person(你们,北京);/** 不对equals进行重写System.out.println(p2.equals(p));返回的是Boolean类型的值比较的是两个对象的地址值不是比较两个类的内容是否一致*///方法重写后输出System.out.println(p2.equals(p));//重写方法后比较的是两个对象的内容是否一致}
}继承学习综合练习
class Wapon
{String name;void WaponAttack(){System.out.println(武器攻击); }}
class K98 extends Wapon
{void WaponAttack()//重写父类方法{System.out.println(98K攻击);System.out.println(一击毙命);}
}
class Dao extends Wapon
{void WaponAttack()//重写父类方法{System.out.println(砍刀攻击);System.out.println(刀刀见血);}
}
class Play
{String name;String level;Wapon wapon;int id;void attack(){System.out.println(玩家攻击);wapon.WaponAttack();}
}
public class Main {public static void main(String[] args) {Play p1new Play();p1.name玩家一;p1.level青铜;//p1.wapon new Wapon();p1.wapon new Dao();//多态p1.attack();//如果直接写这句话会出现空指针异常要先给wapon赋值再使用System.out.println();p1.wapon new K98();//多态p1.attack();//如果直接写这句话会出现空指针异常要先给wapon赋值再使用}
}java继承的简单工厂模式
工厂模式之前在写智能家居的代码的时候用C语言加链表实现过在用C语言实现时就是构建了连个链表分别代表指令工厂和控制工厂然后将设备通过添加节点的方式插入到对应的链表在使用的时候通过设备或者指令名称进行查找然后调用相关的函数实现起来比较繁琐。而在java中有了继承的概念就可以将那些结点看作是继承自一个父类的子类然后构建一个查找的类对所需要的内容进行查找即可查找到返回查找的对象的引用然后就可以调用相关的方法。实现起来比较简单。
class Fruit //相当于之前用C语言写的链表的头部
{String name;void grow(){System.out.println(野蛮生长的水果); }public Fruit(String name){this.namename; }
}
class Apple extends Fruit
{public Apple(String name){super(name);}void grow()//对父类方法进行重写{System.out.println(野蛮生长的name);}
}
class Peach extends Fruit
{public Peach(String name){//构造方法调用父类的构造方法super(name);}void grow()//对父类方法进行重写{System.out.println(野蛮生长的name);}
}
class Factory //在这个类里面进行对水果的查找
{public static Fruit getFruit(String name){if(name苹果)return new Apple(name);//这里有用到多态else if(name桃)return new Peach(name);else{return null;}}
}
public class Main {public static void main(String[] args) {if(Factory.getFruit(苹果)!null){System.out.println(找到了苹果);Factory.getFruit(苹果).grow();}if(Factory.getFruit(桃)!null){System.out.println(找到了桃);Factory.getFruit(桃).grow();}if(Factory.getFruit(葡萄)null){System.out.println(没有该水果);}}
}抽象类
Java中可以定义没有方法体的方法该方法由子类来具体实现。该没有方法体的方法我们称之为抽象方法含有抽象方法的类我们称之为抽象类。
抽象方法的特点① 只有方法头没有方法体的方法称为抽象方法。② 抽象方法用abstract来修饰。③ 抽象方法代表一种不确定的操作或者行为。④ 抽象方法不能被调用。⑤ 抽象类代表一种抽象的对象类型。 ⑥ 抽象类不能实例化 ⑦ 抽象类中可以有具体方法可以没有抽象方法。
abstract class Demo1
{abstract public void method();//抽象方法只能放在抽象类里面在这里声明抽象方法就要将类声明为抽象类
}
class Demo2 extends Demo1 //抽象类使用的时候一般是使用新的类继承抽象类然后重写里面的抽象方法
{public void method(){System.out.println(Demo2重写的Demo1的方法);}
}
public class Main {public static void main(String[] args) {/** 抽象类在使用的时候不能实例化* 添加函数体则如下所示对里面的抽象方法进行补充这种方式算不上实例化是做的一个匿名的内部类* Demo1 dnew Demo1(){public void method() {}};*/Demo2 dnew Demo2();d.method();}
}模板方法模式也是抽象类的一种使用方法
定义 一个模板方法用一些抽象的操作定义一个算法而子类将重定义这些操作以提供具体行为。 意图 定义了一个操作中的一个算法框架把一些步骤推迟到子类去实现模板方法让子类不需要改变算法结构。
具体的代码示例
abstract class Contrl //这个控制类只是做一个模板放到这里因为每一个抽象方法实现不一样
{abstract void initUsart();abstract void getComand();abstract void openCure();abstract void openLight();abstract void OpenTv();public void work() //这个方法里面是一系列的控制流程里面是抽象方法{initUsart();getComand();openCure();openLight();OpenTv();}
}
class STM32contrl extends Contrl //继承自contrl这个类然后会让我们实现父类这个抽象类的所有抽象方法
{void OpenTv() {// TODO Auto-generated method stubSystem.out.println(STM32 OpenTv);}void getComand() {// TODO Auto-generated method stubSystem.out.println(STM32 getComand);}void initUsart() {// TODO Auto-generated method stubSystem.out.println(STM32 initUsart);}void openCure() {// TODO Auto-generated method stubSystem.out.println(STM32 openCure);}void openLight() {// TODO Auto-generated method stubSystem.out.println(STM32 openLight);}
}
class C51contrl extends Contrl //继承自contrl这个类然后会让我们实现父类这个抽象类的所有抽象方法
{void OpenTv() {// TODO Auto-generated method stubSystem.out.println(C51 OpenTv);}void getComand() {// TODO Auto-generated method stubSystem.out.println(C51 getComand);}void initUsart() {// TODO Auto-generated method stubSystem.out.println(C51 initUsart);}void openCure() {// TODO Auto-generated method stubSystem.out.println(C51 openCure);}void openLight() {// TODO Auto-generated method stubSystem.out.println(C51 openLight);}
}
public class Main {public static void main(String[] args) {STM32contrl stm32new STM32contrl();stm32.work();//STM32contrl这个类也继承了Contrl的work方法该方法是总的控制流程C51contrl c51new C51contrl();c51.work();}
}接口的概念和作用
接口语法interface 接口{ //公有静态方法、抽象方法 }
接口的特点 ① 接口中只能存放静态常量和抽象方法 ② java接口是对功能的拓展 ③ 通过实现接口java类可以实现多实现 ④ 一个类可以同时继承extends一个父类并且实现implement多个接口 ⑤ 接口与接口之间可以使用extends实现继承。
接口与抽象类的区别
抽象类和具体实现之间是一个继承关系也就是如果采用抽象类的方式则父类和子类在概念上应该是相同的。接口和实现类在概念上不要求相同接口只是抽取相互之间没有关系的类的共同特征而不去关注类之间的关系它可以使没有层次关系的类具有相同的行为。抽象类是对一组具有相同属性和行为的逻辑上上有关系的事物的一种抽象而接口则是对一组具有相同属性和行为的逻辑上不相关的事物的一种抽象。 interface Move
{abstract void eat();abstract void drink();
}
class man implements Move
{public void eat() {System.out.println(人类吃); }public void drink() {System.out.println(人类喝); }
}
class animal implements Move
{public void eat() {System.out.println(动物吃); }public void drink() {System.out.println(动物喝); }
}
public class Main {public static void main(String[] args) {new man().drink();new animal().eat(); }
}内部类
概念 所谓的内部类Inner Class顾名思义就是将一个类定义在另一个类的内部内部的类称之为内部类。特点 ① 内部类可以很好的实现隐藏可以使用protected、private修饰符。② 内部类可以直接访问外部类所有成员包括私有成员。③ 外部类不能直接访问内部类的成员必须首先建立内部类对象才能访问。成员内部类及应用 ① 成员内部类属于外部类的实例成员成员内部类可以有public、private、default、protected权限修饰符。在成员内部类中访问外部类的成员方法和属性要使用“外部类名.this.成员方法”和“外部类名.this.成员属性”的形式 。② 创建成员内部类的实例使用“外部类名.内部类名 实例外部类实例名.new 内部类 构造方法(参数)”的形式。成员内部类有以下限制 ① 成员内部类不能与外部类重名 ② 不能在成员内部类中定义static属性方法和类static、final形式的常量定义除外因为一个成员内部类实例必然与一个外部类实例关联static成员完全可以移到其外部类中去。在一个java文件中只能有一个public类如果有多个就要放在其他文件中
class Outer
{int data;public Outer(int data) {this.datadata;}void printfData(){System.out.println(外部类打印外部类datadata);}class Inner{int data;public Inner(int data) {this.datadata;}void printfData(){System.out.println(内部类打印外部类的dataOuter.this.data);System.out.println(内部类打印内部类的datadata);}void printouter(){System.out.println(内部类调用外部类方法打印data如下);Outer.this.printfData();}}
}
public class Main {public static void main(String[] args) {// 创建成员内部类的实例使用 外部类名.内部类名 实例外部类实例名.new 内部类 构造方法(参数)的形式。Outer Out1new Outer(10);//创建成员内部类的实例得先创建外部类的实例Outer.Inner In1Out1.new Inner(20);Out1.printfData();In1.printfData();In1.printouter();}
}匿名内部类及应用
内部匿名类 一个带具体实现的父类或者父接口的匿名的子类对象。匿名内部类的特点 ① 匿名内部类是没有名称的内部类没办法引用他们。必须在创建时作为new语句的一部分来声明并创建他们的实例。② 匿名内部类必须继承一个类抽象的、非抽象的都可以或者实现一个接口所有的父类或者父接口是抽象类则匿名内部类必须实现其所有抽象的方法。语法 实例一个匿名内部类---- new interface/superclass(){类体}这形式的new语句声明一个新的匿名类它对一个给定的类进行扩展或者实现一个给定的接口并同时创建该匿名类的一个新实例。
abstract class Demo
{abstract void printfInfo();abstract void interPrintf();//在接口中默认是抽象方法
}
interface Demo2
{void interPrintf();//在接口中默认是抽象方法
}
public class Main {public static void main(String[] args) {new Demo(){void printfInfo() {System.out.println(这不是demo类的实例化而是匿名内部类的方法);}void interPrintf() {System.out.println(所有的父类或者父接口是抽象类则匿名内部类必须实现其所有抽象的方法);}}.printfInfo();// Demo dnew Demo(){这种形式是以多态的形式创建匿名内部类new Demo()是Demo 的子类的对象在这里用父类引用来接收的
// void printfInfo() {
// System.out.println(这不是demo类的实例化而是匿名内部类的方法);
// }
// void interPrintf() {
// System.out.println(所有的父类或者父接口是抽象类则匿名内部类必须实现其所有抽象的方法);
// }
// };
// d.interPrintf();
// d.printfInfo();new Demo2(){public void interPrintf() {System.out.println(这不是接口的实例而是匿名内部类的方法); }}.interPrintf();}
}
