黑马程序员——java-面向对象二(继承,多态,抽象,接口,包,内部类)
来源:互联网 发布:帝国cms安装地址 编辑:程序博客网 时间:2024/04/29 14:55
———–android培训、java培训、java学习型技术博客、期待与您交流!————
1
继承:
(1)把多个类中相同的内容提取出来,定义到一个类中。 然后让这多个类和这个类产生一个关系,这多个类就具备该类的数据了。 这种关系叫:继承。(2)表现形式: class SonClass extends FuClass {} SonClass: 子类,派生类 FuClass: 父类,基类,超类(3)继承的好处: A:提高了代码的复用性。 B:让类与类之间产生了一个关系,是多态的前提。(4)Java中继承的特点: A:Java中类只支持单继承。 B:Java中类可以多层(重)继承。(5)继承间的成员关系:
A:成员变量 在子类方法中使用变量:(在找的时候的顺序) 先找本类中方法的:局部范围 再找本类中的: 成员范围 在找: 父类成员范围
package extendsText;public class bianliang{ public static void main(String[] args) { Student1 t1=new Student1(); t1.getNum(); }}class Persion1{ public int num=100; public int num1=300;}class Student1 extends Persion1{ public int num=200; public void getNum() { System.out.println(num);//输出200 System.out.println(num1);//输出300,使用的是父类的成员变量 }/*继承中,成员变量的使用:A;首先在本类方法的局部位置找此变量(num,和num1都没有在局部位置), B;局部没有就在,本类的成员位置找,(num在此类的成员位置,找到了就使用了,而num1还是没有找到) C:继续在父类的成员位置找(num1在父类的成员位置找到了就是用父类的) */}
B:构造方法 a:子类构造方法中默认去访问父类的无参构造方法。 原因:因为子类要使用父类的数据,父类的数据必须先初始化。(每一个构造方法第一行都已一个隐含的super(),调用父类无参构造方法,)隐含的super()写不写都可以 b:假如子类没有构造方法 要么,使用super(...)调用带参 要么,使用this(...)访问本类其他构造,本类至少有一个构造方法访问了父类构造方法。
package extendsText;import java.util.jar.Attributes.Name;public class extendsText{ public static void main(String[] args) { Student s = new Student("赵云", 20, "这个红柱"); s.f2(); }}class Persion{ private String name; private int age; public Persion(String name, int age) { this.name = name; this.age = age; System.out.println("我是Persion的构造"); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }}class Student extends Persion{ private String address;// 住宿地址 private long number;// 学号 public Student(String name, int age, String address) { super(name, age);//先调用父类带两个参数的构造方法。 this.address = address; System.out.println("我是Student的构造"); } public void f2() { System.out.println(super.getName() + "---" + super.getAge() + "---" + address); }}
C:成员方法 通过子类对象使用成员方法: 子类:可以调用父类的方法,因为子类继承了父类的东西 父类:父类不能调用子类特有的方法
2
方法重写(1)子类中出现了和父类中方法声明一模一样的方法。 复写,覆盖。(2)注意事项: A:子类方法的权限不能低于父类方法的权限 B:父类私有的不能被重写 C:静态只能重写静态。(多态中讲解一个问题)
package extendsText;public class gouzaoff{ public static void main(String[] args) { zi z=new zi(); z.getName(); }}class fu{ public void getName() { System.out.println("我是fu类中的方法"); }}class zi extends fu{ public void getName()//重写父类中的方法 { System.out.println("我是zi类中的方法"); }}
6
面试题:(
(1)方法重载和方法重写的区别? 方法重载:函数名相同,参数列表不同,跟返回值类型无关(所以可以改变返回值类型) 方法重写:函数的声明相同,(2)this和super的区别? this:表示当前类的引用对象,谁调用,代表谁 super:父类的存储空间的表示,可以理解为父类的对象应用场景: A:成员变量 this:this.成员变量 表示本类的成员变量 super:super.成员变量 表示父类的成员变量 B:成员方法 this.成员方法 表示调用本类的成员方法 super.成员方法 表示调用父类的成员方法 C:构造方法 this() 表示调用本类的构造方法 super() 表示调用父类的构造方法
7
final
(1)是一个关键字,表示的是最终的意思。(2)它可以修饰类,修饰成员变量,修饰成员方法。(3)特点: 它修饰的类不能被继承。 它修饰的变量是常量。 它修饰的成员方法不能被重写。(4)面试题: 修饰局部变量 用final修饰的局部变量的值是固定的,不能再被改变 方法的形式参数: 基本类型:基本类型的值不能发生改变。 引用类型:引用类型的地址值不能发生改变,但是内容可以发生改变(5) final:可以修饰局部变量,也可以修饰成员变量 private:不能修饰局部变量,可以修饰成员变量 (不能修饰局部变量,用private修饰的目的是把该变量私有化,保证不能让外界访问,而在方法中的局部变量,外界就已经不能访问的) 用fianl修饰的变量在内存的方法区的常量区中存放着
8
多态
(1)同一个对象在不同时刻表现出现的多种状态。 举例: 水(水蒸气,冰,水) 理解: 编译时期状态和运行时期状态不一致的现象。 判断下面哪个有问题:从右边往左边念。 Fu f = new Fu(); Zi z = new Zi(); Fu f = new Zi(); //多态 Zi z = new Fu(); //报错(2)多态的前提: A:要有继承或者实现关系。 B:有方法重写。 因为一般都是抽象类或者接口的多态。 C:要有父类/父接口的引用指向子类对象。(3)多态访问的成员特点: Fu f = new Zi(); A:成员变量 编译看左边,运行看左边。(因为成员变量不存在重写) B:成员方法 编译看左边,运行看右边。(只有方法存在重写) C:静态方法 编译看左边,运行看左边。(4)多态的好处和弊端: A:好处 提高了程序的可维护性和可扩展性。 维护性:继承保证 扩展性:多态保证 B:弊端 父类/父接口不能访问子类特有功能。(5)多态中的类型转换: A:向上转型 Fu f = new Zi(); B:向下转型 Zi z = (Zi)f; 举例:孔子装爹。(6)多态的体现形式: A:具体类多态 class Fu {} class Zi extends Fu {} Fu f = new Zi(); B:抽象类多态 abstract class Fu {} class Zi extends Fu {} Fu f = new Zi(); C:接口多态 interface Inter {} //接口的实现类命名:接口名+Impl class InterImpl implements Inter{} Inter i = new InterImpl();
多态机制(又称动态绑定)
重要的一点:父类的对象是不访问继承它的子类中的属性和方法的
在Fu f = new Zi();的时候,对象f中有this指向Fu类中的方法。而在f对象调用方法的那一刻,f.method(),f对象中的this随即就指向了zi类中的重写Fu类中的method()方法
public class duotai{ public static void main(String[] args) { Fu p1=new Zi(); p1.method(); }}class Fu{ public void method() { System.out.println("我是父类中的方法"); }}class Zi extends Fu{ public void method() { System.out.println("我是子类中的方法"); }}
图示:
9
抽象:(abstract)
抽象类:
(1)把多个类中相同的方法声明给抽取出来。定义到一个类中。 一个方法如果只有方法声明,没有方法体,那么该方法必须定义为抽象方法。 而一个类中如果有抽象方法,那么,该类必须定义为抽象类。(2)抽象类的特点: A:抽象方法和抽象类都必须用abstract表示。 B:一个类继承抽象类的时候; 要么:本身是一个抽象类。 要么:实现抽象类中的所有抽象方法。 C:抽象类不能实例化。可以按照多态的使用方式使用。 D:成员特点: a:成员变量 可以是变量,也可以是常量。 b:构造方法 有 c:成员方法 可以是抽象,也可以非抽象。(3)抽象类的好处: A:抽象类中的非抽象方法提高了代码的复用性。 B:抽象类中的抽象方法强制要求子类必须重写某些方法。(4)抽象类的案例: A:鸟狗案例
package extendsText;abstract class Animal//抽象类{ public abstract void sing();}class Brad extends Animal //继承抽象类,并重写抽象方法{ public void sing() { System.out.println("我是小鸟的叫声"); }}class Dog extends Animal//继承抽象类,并重写抽象方法{ @Override public void sing() { System.out.println("我是小狗的叫声"); }}public class chouxiang__Text{ public static void main(String[] args) { Animal d=new Brad();//多态 d.sing(); Animal g=new Dog();//多态 g.sing(); }}
(5)抽象类中的几个小问题: A:抽象类不能实例化,构造方法有什么用呢? 用于子类访问父类数据的初始化。 (因为子类继承了父类,在子类中默认首先调用父类没有参数的构造方法) B:如果一个类中没有抽象方法,而类却被定义为了抽象类,请问为什么? 不让创建对象。 C:abstract不能和哪些关键字共存: private: 冲突 final: 冲突 static: 无意义
abstract class Anima {public abstract static void sing();//静态修饰的东西,可以通过类名直接调用,但是,该方法是抽象的没有方法体,所以没有意义}
10
接口(interface) (特殊的抽象类)
(1)如果一个抽象类中的所有成员方法都是抽象的,java就提高了一种更抽象的表达方式:接口。(2)接口的特点: A:接口用interface定义。 类实现接口用implements关键字。 B:一个类要实现接口: 要么:本身是抽象类。 要么:实现接口中的所有抽象方法。 C:接口不能实例化。可以按照多态的使用方式使用。 D:成员特点: a:成员变量:只能是常量。 默认修饰符:public static final b:成员方法:只能是抽象方法。 默认修饰符:public abstract(3)类与接口的关系: A:类与类的关系 继承,单继承。 B:类与接口的关系 实现,单实现,多实现。 继承一个类的同时实现多个接口。 C:接口与接口的关系 继承,单继承,多继承。(4)案例: A:猫狗案例用接口实现基本版本。
package extendsText;interface Animal{ public abstract void sing();}class Brad implements Animal { public void sing() { System.out.println("我是小鸟的叫声"); }}class Dog implements Animal{ @Override public void sing() { System.out.println("我是小狗的叫声"); }}public class chouxiang__Text{ public static void main(String[] args) { Animal d=new Brad(); d.sing(); Animal g=new Dog(); g.sing(); }}
(5)抽象类和接口的区别: A:成员区别 抽象类: a:成员变量 可以是变量,也可以是常量。 b:构造方法 有 c:成员方法 可以是抽象,也可以非抽象。 接口: a:成员变量:只能是常量。 默认修饰符:public static final b:成员方法:只能是抽象方法。 默认修饰符:public abstract B:关系区别 a:类与类的关系 继承,单继承。 b:类与接口的关系 实现,单实现,多实现。 继承一个类的同时实现多个接口。 c:接口与接口的关系 继承,单继承,多继承。 C:设计理念不同 抽象类被继承体现的是:is a的关系。抽象类中定义的是继承体系共性功能。 接口被实现体现的是:like a的关系。接口中定义的是继承体系的扩展功能。
11
1 包(package)
(1)其实就是文件夹。(2)作业:把同名称的类放到不同的文件夹下使用。(3)格式: package xxx.yyy.zzz;(4)带包的类的编译和运行: A:手动式 a:javac编译当前类文件。 b:手动建立包对应的文件夹。 c:把a的class文件放到b的最终文件夹下。 d:通过java命令执行。注意了:需要带包名称的执行。 java cn.itcast.HelloWorld B:自动式 a:javac编译的时候带上-d即可 javac -d . HelloWorld.java b:通过java命令执行。注意了:需要带包名称的执行。 java cn.itcast.HelloWorld
2
导包
(1)不同包下的类之间的访问。 我们发现,每次使用不同包下的类的时候,都需要加包的全路径。 比较麻烦。这个时候,java就提供了导包的功能。(2)格式: import xxx.yyy.zzz.类名; 扩充格式: import xxx.yyy.zzz.*; 但是不建议使用这种做法。(3)面试题: package,import,class的有没有顺序呢? package > import > class 唯一(包) 多个(import) 多个(类)
3
权限修饰符
(1)结论: 本类 同一个包下 不同包下的子类 不同包下的无关类 private Y 默认 Y protected Y Y Y public Y Y Y Y
(2)常见的修饰符的使用
(12)
内部类:
(1)把类定义在其他类的内部,就被称为内部类。(2)内部类的访问特点: A:内部类可以直接访问外部类的成员,包括私有。 B:外部类要访问内部类的成员,必须创建对象。
class Persion//外部类{ private String name; int age; class Student//内部类 { private String address; public void get() { System.out.println(name+"-------"+age); method(); } } public void method() {//外部类要适应内部类的东西,首先要创建内部类的对象 System.out.println(new Student().address); }}
(3)内部类的分类: A:成员 部类 a:private 访问的安全性
package neibulei;class Outer{ private class Inner// 内部类被private修饰,需要提供方法接口来调用内部类中的方法 { public void mehtod() { System.out.println("我是内部类中的method1方法,我被peivate修饰"); } } public void getMethod()//提供一个可以调用的方法 { Inner inner = new Inner();//创建内部类对象, inner.mehtod();//调用内部类方法 }}public class neibulei____xiushi{ public static void main(String[] args) { Outer outer = new Outer(); outer.getMethod();//如果,内部类被public修饰,可以这样创建内部类对象//Outer.Inner oiInner=new Outer().new Inner(); }}
b:static 访问的方便
package neibulei;class Outer{ static class Inner// 内部类被static修饰,在创建内部类对象的时候,不用再创建外部类对象 { public void mehtod() { System.out.println("我是内部类中的method1方法,我被static修饰"); } }}public class neibulei____xiushi{ public static void main(String[] args) { Outer.Inner oiInner = new Outer.Inner();// 创建内部类对象 oiInner.mehtod(); // Outer.Inner.mehtod();如果静态内部类中的方法也是静态的,可以这样调用方法,不用创建对象 }}
B:局部内部类 a:带名字的(类)
局部内部类访问局部成员变量,该局部成员变量需要被声明为final类型 作用:A: 防止该局部变量的数据在使用后被修改B:延长该局部变量的生命周期(正常的局部变量随着方法调用结束,就变成垃圾,而被局部内部类使用的局部变量会随着该内部类结束才结束,这就延长了该局部变量的生命周期)
package neibulei;class Outer1{ public void method()//这是外部类的方法 { final int num = 100; class Inner//这是外部类的方法中的内部类(局部内部类) { public void method() { System.out.println(num); } } Inner inner=new Inner();//局部内部类相当于私有,所以需要首先造局部内部类对象,供使用 inner.method(); }}public class jubu__neibulei{ public static void main(String[] args) { Outer1 oi=new Outer1(); oi.method(); }}
b:不带名字的(对象)
匿名内部类:(掌握) 格式: new 类名或者接口名() { 重写方法; }; 本质:是继承类或者实现接口的子类匿名对象。
(4)面试题: 局部内部类访问局部变量必须加final修饰。匿名内部类:(掌握) 格式: new 类名或者接口名() { 重写方法; }; 本质:是继承类或者实现接口的子类匿名对象。
———–android培训、java培训、java学习型技术博客、期待与您交流!————
0 0
- 黑马程序员——java-面向对象二(继承,多态,抽象,接口,包,内部类)
- 黑马程序员-Java的面向对象(抽象类、接口、内部类和继承、组合、多态)
- 黑马程序员—面向对象(static,封装,继承,多态,内部类,抽象类,接口)总结
- 黑马程序员_面向对象二(继承,多态,抽象类abstract,接口Interface,内部类)
- 黑马程序员 Java面向对象(继承,抽象类,接口,多态,内部类)
- 黑马程序员——Java基础---继承,抽象,多态,接口,包,内部类
- 黑马程序员—Java面向对象(抽象类、模板方法设计模式、接口、多态、内部类)
- 黑马程序员——java基础(面向对象)抽象、接口、内部类
- 黑马程序员——Java基础---面向对象(封装、继承、单例、抽象类、接口、内部类)
- 黑马程序员——继承、抽象、接口、多态、内部类
- 黑马程序员——Java面向对象之抽象类 接口 内部类笔记
- 黑马程序员_面向对象2_(继承、多态、抽象类abstract、接口interface、内部类)
- 黑马程序员——java面向对象(二)继承、抽象、接口
- Java基础——面向对象——继承、抽象类、接口、多态、包、内部类、异常等
- 黑马程序员——面向对象(抽象类、接口、内部类)
- Java基础-->面向对象<继承,内部类,多态,包,抽象与接口>
- 黑马程序员——java面向对象(三)多态、内部类、包
- 黑马程序员——java基础--抽象类、接口、多态、内部类、异常、包
- socket阻塞与非阻塞,同步与异步
- 找出不是两个数组共有的元素
- 线程范围ThreadLocal
- 国外一些人总结的C++库及框架
- java内部类
- 黑马程序员——java-面向对象二(继承,多态,抽象,接口,包,内部类)
- 第八周项目2-Time类中的运算符重载
- “互联网+”草根春天,传统企业怎么办?
- 机房重构总结
- 学学代码,了解测试,从现在开始
- 镜像网站
- windows消息大全
- 10.用户模块:退出登录
- web_reg_find函数在web_submit_data函数前出错的问题