续接上一篇java面向对象基础
- 1. 继承
- 1.1 关键字
- 1.1.1 super
- 1.1.1.1 super内存图
- 1.1.2 this
- 1.2 构造方法
- 1.3 成员方法
- 2. 多态
- 2.1 问题:为何多态中成员方法和成员变量的访问方法不一样?
- 2.2 多态转型
- 2.2.1 向上转型
- 2.2.2 向下转型
- 2.3 多态内存解析
- 3. 接口类
- 3.1 接口特点
- 3.2 接口类成员特点
- 4. 抽象类
- 4.1 抽象类特点
- 4.2 抽象类成员特点
- 5. 类和接口的区别
- 5.1 类和接口的关系
- 5.2 抽象类与接口的区别
- 6. 包
- 6.1 建包
- 6.2 导包
- 7. 修饰符
- 7.1 权限修饰符
- 7.2 状态修饰符
- 7.2.1 final
- 7.2.2 static
对具有相同特征的不同类的提取
关键字extends
形如:public class 子类 extends 父类
特点:子类可以有父类的内容,如果子类对父类的表示不满,可以通过方法重写完成。
***子类只可以继承一个父类,java不支持多继承
1.1 关键字好处:提高代码复用性和维护性
1.1.1 superthis和super
super.成员变量//super访问父类的成员变量 super.() super.成员方法()1.1.1.1 super内存图
https://www.bilibili.com/video/BV18J411W7cE?p=156&spm_id_from=pageDriver
1.1.2 thisthis.成员变量//this访问本类的成员变量 this.() this.成员方法()1.2 构造方法
子类所有的构造方法都会默认访问父类中的无参构造方法
默认有super();
如果父类中没有无参数的构造方法,那么使用super(参数);访问带参数的构造方法就可以了;或者父类中创建无参构造形式就可以了public leiming(){}
//构造方法 public leiming(){}//无参形式 public leiming(int age){}//带参形式1.3 成员方法
//形如 public void method(){}2. 多态
同一个对象,在不同时刻表现出的不同形态
示例
猫 cat = new 猫(); 动物 animal = new 猫(); 猫在不同时刻表现出的不同形态,就是多态
2.1 问题:为何多态中成员方法和成员变量的访问方法不一样?前提和体现
a.有继承/实现关系
b.有方法重写
c.有父类引用指向子类对象;譬如:动物 animal = new 猫();
d.多态的书写方法,编译时看左边也就是父类,运行时看右边,也就是子类
e.多态不能够访问子类的独有的具体的方法
2.2 多态转型因为成员方法有重写,而成员变量没有
2.2.1 向上转型为了解决2.多态的e问题
2.2.2 向下转型从子到父
父类引用指向子类对象
从父到子
父类引用转为子类对象
示例
public class animal { public void eat(){ System.out.println("动物吃东西"); } }
public class cat extends animal { @Override public void eat(){ System.out.println("猫爱吃鱼"); } public void sing(){ System.out.println("这猫会唱歌"); } }
public class test { public static void main(String[] args) { animal a = new cat();//向上转型 a.eat(); cat c = (cat)a;//向下转型 c.sing(); c.eat(); } }
//output 猫爱吃鱼 这猫会唱歌 猫爱吃鱼2.3 多态内存解析
多态的内存解析b站视频
3. 接口类 3.1 接口特点a. 修饰关键字interface;形如public interface 接口名 {}、
b.类实现接口,形如:public class 类名 implements 接口名{}
c.接口不能实例化;但可以参照多态的方式,通过实现类对象实例化,这叫接口多态
i:多态的形式:具体类多态、接口多态、抽象类多态
ii:多态的前提:有继承或者实现关系、有方法重写、有父(类/接口)引用指向(子/实现)类对象
d.接口的实现类:要么重写接口中的所有抽象方法、要么本身定义为抽象类
示例
//定义接口 public interface Animal { //接口抽象方法 public abstract void eat(); }
//继承接口 public class Cat implements Animal{ //重写接口方法 @Override public void eat() { System.out.println("cat eat fish"); } }
//抽象类继承接口 public abstract class Dog implements Animal{ }
public class Test { public static void main(String[] args) { //创建接口对象 Animal animal = new Cat(); animal.eat();//调用子类重写方法 } }
//output cat eat fish3.2 接口类成员特点
a.接口中的参数只能是常量,默认修饰符public final static
b.接口中的方法默认修饰符public abstract
c.接口中没有构造方法,因为接口主要是对行为进行抽象,是没有具体存在的;
d.一个类如果没有父类,默认继承Object超类
示例
//这两个在接口中是等价的,参数默认修饰符public final static public final static String name = "bob"; String name = "bob";
// public Animal(){}//没有构造方法 // public void show(){}//没有构造方法 public abstract void show();
//public class Cat implements Animal{ public class Cat extends Object implements Animal{ //默认继承Object超类,这两种书写格式是等价的 public Animal(){ super(); } }
public abstract void eat();//方法默认修饰符public abstract void eat();4. 抽象类 4.1 抽象类特点
a. 一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类
b.而一个抽象类中可以没有抽象方法
c.抽象类的继承必定是抽象类
d.抽象类不能实例化,但是可以通过多态的方式,对子类进行实例化,又称为抽象多态
e.抽象类的子类要么重写父类的所有抽象方法,要么本身就是一个抽象类
示例
//抽象类 public abstract class Animal { //抽象方法 public abstract void eat(); public void sleep(){ System.out.println("animal sleeping"); } }
public class Cat extends Animal{ //子类重写父类的抽象方法 @Override public void eat(){ System.out.println("cat eat fish"); } }
//子类本身是抽象类 public abstract class Dog extends Animal{ //public abstract void eat(); }
public class Test { public static void main(String[] args) { //创建子类对象实例 Animal animal = new Cat(); //调用对象方法 animal.eat();//子类修改后的方法 animal.sleep();//父类 } }
//output cat eat fish animal sleeping4.2 抽象类成员特点
a.成员变量可以是常量,也可以是变量
b.可以包含构造方法。作用:用于子类访问父类数据的初始化
c.成员方法:可以有抽象方法,限定子类必须完成某些动作;也可以有非抽象方法,提高代码复用性
示例代码
package com.Abstract; //抽象类 public abstract class Animal { //常量+变量 private int age = 20; private final String address = "street 7"; //无参数构造方法 public Animal(){} //含参构造方法 public Animal(int age){ this.age = age; } //show()方法 public void show(){ int age = 40; System.out.println(age); System.out.println(address); } //抽象方法 public abstract void eat(); public void sleep(){ System.out.println("animal sleeping"); } }
//output cat eat fish animal sleeping 40 street 75. 类和接口的区别 5.1 类和接口的关系
a.类与类的关系:继承关系,只能单继承,但是可以多层继承
b.类与接口得关系:实现关系。可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口
c.接口与接口的关系:继承关系。可以单继承,也可以多继承。
示例
public class inter extends Object implements inter1,inter2,inter3 {//多继承 }
public interface inter3 extends inter1,inter2{//继承关系 }5.2 抽象类与接口的区别
示例
package
手动建包:文件夹打开创建即可
自动建包:编译时输入命令
javac -d . HelloWorld.java6.2 导包
7. 修饰符 7.1 权限修饰符现在idea已经可以自动导包了,达咩嘻嘻;否则需要写出所调用包的全路径;eg:s.HelloWorld.hello();
关键字import
7.2 状态修饰符 7.2.1 final这个写过了,看这里4种权限修饰符
7.2.2 statica.可以修饰成员方法、变量、类;不可修改;被final修饰的类不可以被修改,子类不可继承不可重写,修饰变量直接变为常量
b.修饰局部变量,修饰基本类型变常量,修饰引用类型地址值不改变
a.static表示静态,可以修饰成员方法,成员变量
b.特点:被类的所有对象共享;这是判断是否是静态关键字的特点;
c.调用:通过类名调用,或者对象名调用
d.静态成员方法只能访问静态成员变量;而非静态的可以访问ALL
注意:main方法是静态的,所以一般写方法时大多会选择静态,方便main方法调用
示例:
public class person { String name; static String address; public void show(){ System.out.println("name:"+name+"n"+"address:"+address); } }
public class test { public static void main(String[] args) { person p = new person(); //调用 person.address = "street 7"; p.name = "bob"; p.show(); } }
//output name:bob address:street 7
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)