一,构造方法
–1,概述
–创建对象时会自动调用构造方法
–构造方法和其他方法一样也可以重载
–作用:完成对象的创建或者完成对象的初始化
–2,语法:
–普通方法:修饰词 返回值 方法名(参数列表){方法体}
–构造方法:修饰符 类名(参数列表){方法体}
–3,构造方法完成创建对象
package cn.tedu.oop;
//测试 构造方法Constructor / 构造器
//总结
//1,触发的时间节点:构造方法摆在那儿不会主动执行,需要new来触发
//2,构造方法可以重载,为了方便各种new,体现程序的灵活性
//3,构造方法在创建对象时,会自动执行
public class Test1_Constructor {
public static void main(String[] args) {
//创建对象测试
new Student(“1”,2);//触发了public Student(String a,int b)
new Student();//触发无参构造
new Student(“1”);//触发了public Student(String name)
new Student(1);//触发了public Student(int a)
new Student(1,2);//触发了public Student(int a,int b)
}
}
//创建Student类
class Student{
public Student(String a,int b) {
System.out.println(“含参构造,名字是:”+a+",年龄是:"+b);
}
//1,提供构造方法:修饰符 类名(参数列表){方法体}
//5,默认就会存在无参构造–前提是.不能只提供含参的构造方法
public Student() { }
//3,重载-- 在同一个类里,方法名相同,但是参数列表不同
public Student(String name) {
System.out.println(“含参构造方法”+name);
}
public Student(int a) {
System.out.println(“含参构造方法”+a);
}
public Student(int a,int b) {
System.out.println(“含参构造方法”+a+b);
}
}--4,构造方法完成对象的初始化
package cn.tedu.oop;
//测试 构造方法 初始化对象信息
public class Test2_Constructor2 {
public static void main(String[] args) {
//1,需求:在创建对象时,给成员变量初始化
Student2 s = new Student2("钟南山",85);
//6,获取 私有属性 的值
System.out.println( s.getName() );//钟南山
System.out.println( s.getAge() );//85
}
}
class Student2{
//2, 给成员变量初始化--setXxx()--直接构造方法赋值
private String name;
private int age;
//5,只对外提供获取方式
public String getName() {
return name;
}
public int getAge() {
return age;
}
//3,默认就存在的 无参构造
public Student2() {}
//4,提供含参构造,并完成成员变量的初始化
public Student2(String a,int b) {
name = a;
age = b;
}
}二,代码块
–1,概述
–被花括号包起来的一段代码就叫代码块
–代码块的位置不同,作用用法名字都不同
–2,构造代码块
–成员位置(类里方法外)的代码块叫构造代码块
–作用:通常用于抽取构造方法中的共性代码
–顺序:new时,先调用构造代码块,然后调用构造方法,优先于构造方法加载
–3,局部代码块
–局部位置(方法里)的代码块叫局部代码块
–作用:通常用于控制变量的作用范围
–4,测试:
package cn.tedu.oop;
//测试 代码块
//总结
//1,创建对象时:本来是只会触发构造方法,但是,如果有构造代码块,就会先触发构造代码块再执行构造方法
//2,调用方法时:顺序执行方法里的代码,如果有局部代码块也就一起执行
//3,执行顺序:new时–构造代码块>构造方法,调用方法时–局部代码块
//4,构造代码块–用来提取构造方法的共性–new时才触发
//5,局部代码块–用来控制变量的作用范围–调用方法时才触发
public class Test3_Block {
public static void main(String[] args) {
new Person().show();//触发无参构造
new Person(“熊大”);//触发含参构造
}
}
//创建Person类
class Person{
//1,构造代码块:位置是在成员位置–触发节点是 new时–先执行构造代码块再执行构造方法
//–作用:抽取构造方法的共性
int age ;
{
age = 0 ;//提取了所有构造方法的共性功能
System.out.println(“构造代码块”);
}
public Person() {
System.out.println(“无参构造方法”+age);
}
public Person(String name) {
System.out.println(“含参构造方法”+name+age);
}
//2,局部代码块:位置是在方法里–触发节点是 当方法被调用时–用来控制变量的作用范围
public void show() {
{
int x = 10;
System.out.println(x);
System.out.println(“局部代码块”);
}
}
}三,this关键字
–1,代表本类对象的一个引用对象
–2,作用:
–用来区分同名的成员变量和局部变量
–用来完成构造方法间互相调用
–3,测试1
package cn.tedu.oop;
//测试 this关键字
//总结
//当局部变量名 和 成员变量名 相同时,需要用this调用 成员变量
public class Test4_This {
public static void main(String[] args) {
//通过对象,来访问类里的成员(成员变量和成员方法)
new Demo().test();
// Demo d = new Demo() ;
// System.out.println( d.name );
System.out.println( new Demo().name );
}
}
//创建Demo类
class Demo{
String name ;
int count = 20 ;//成员变量public void test() {
int count = 10;//局部变量
System.out.println(count);//变量的就近原则,会使用局部变量 的值 10
System.out.println(name);//成员变量
//1,想要使用 和 局部变量 同名的 成员变量count--this调用成员变量
//this表示的是本类的对象的引用--底层帮你new了一个本类对象--Demo this = new Demo();
System.out.println( this.count );//20,成员变量
}
}
--4,测试2
package cn.tedu.oop;
//测试 this--用来完成 构造方法间 互相调用
//总结
//1,如果在构造方法间,互相调用时,this不能省略
//2,位置必须是第一条语句
public class Test5_This2 {
public static void main(String[] args) {
// new Demo2();
new Demo2(1);
}
}
class Demo2{
public Demo2() {
//1,在 无参构造里 调用 含参构造
// this(10);
System.out.println("无参构造");
}
public Demo2(int a) {
//2,在 含参构造里 调用 无参构造
this();//3,在构造方法中,使用this关键字,必须是第一条语句
System.out.println("含参构造"+a);
}
}四,继承
–1,概述
Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数 据或新 的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。
–2,好处
提高父类代码的复用性,减少子类代码的编写,提高开发效率
–3,特点
–使用extends关键字
–相当于子类把父类的功能复制了一份
–java只支持单继承
–继承可以传递（爷爷，儿子，孙子的关系）
–不能继承父类的私有成员
–继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
–像是is a 的关系
–4,入门案例
package cn.tedu.oop;
//测试 继承
public class Test6_Extends {
public static void main(String[] args) {
//创建Dog对象测试
new Dog().eat();
new Dog().sleep();
System.out.println( new Dog().name );
}
}
class God{
String name ;
}
//1,父类来了–提取子类的共性–提高了代码的复用性
class Animal extends God{
//5,父类的私有成员(成员变量/成员方法)不能被继承
private double sifangmoney = 100 ;public void eat() {
System.out.println("啥都吃");
}
}
//2,子类想拥有父类的功能--需要发生继承关系
class Dog extends Animal{//4,java只支持单继承
//3,相当于子类把父类的功能复制了一份
//6,除了能用父类继承来的,还可以自己做扩展
public void sleep() {
System.out.println("sleep()..");
}
}
class Cat{
}
--5,super关键字
--1,在子类中用,用来访问父类的成员(成员变量/成员方法)
--2,super表示父类对象的引用,底层自动创建了一个父类的对象
--3,如果在构造方法里使用super关键字,位置上必须是第一条语句
--6,方法的重写override
--1,重写的前提是:发生继承关系+子类的方法声明和父类一样
--2,啥时候需要重写?--想要改,改掉父类原来的实现时一,继承的使用
–1,成员变量
package cn.tedu.oop;
// 测试 继承成员变量 的使用
//总结 : 在子类中,想用父类的成员变量
//1,子类和父类的变量名不相同时,可以省略super.
//2,子类和父类的变量名相同,必须用super来调用父类的资源,不能省略
public class Test1_Extends {
public static void main(String[] args) {
new Zi().show();
}
}
class Fu{
int count = 10;
int sum = 30 ;
}
class Zi extends Fu{
int num ;
int sum = 20 ;public void show() {
int sum = 10 ;
System.out.println(sum);//10,就近原则
System.out.println(num);//0,使用了默认值
System.out.println(this.sum);//this能够调用本类的成员变量
//1,super代表父类对象的引用.可以在子类中,使用父类的内容
//2,相当于super帮你创建了一个父类对象,Fu super = new Fu();
System.out.println(super.count);//10,用了父类的 不同名的变量,可以省略super.
System.out.println(super.sum);//30,用了父类的,和子类同名了
}
}
--2,成员方法
package cn.tedu.oop;
//测试 继承成员方法 的使用
//1,子类 可以继承父类的方法们 -- 可以直接使用
//2,子类 可以进行扩展 -- 可以直接使用
//3,子类 可以修改继承来的方法 -- 方法的重写override
//4,什么时候需要重写?--想要改时!!!
public class Test2_Extends2 {
public static void main(String[] args) {
//4,创建子类对象测试
Zi2 zi = new Zi2();
zi.eat();//重写前,使用了父类的,重写后,使用子类的
zi.study();//重写前,使用了父类的,重写后,使用子类的
zi.sleep();//子类特有的
}
}
class Fu2{
public void eat() {
System.out.println("爸爸在吃猪肉");
}
public void study() {
System.out.println("爸爸在学搓麻");
}
}
class Zi2 extends Fu2{
//2,子类可以把父类的所有方法都继承来使用,也可以修改(方法重写)
//要求:继承+子类的方法声明和父类必须一样
public void eat() {
//3,调用父类原来的eat()--重写并不会影响父类的原有功能
// super.eat();
System.out.println("儿子在吃菜");
}
public void study() {
System.out.println("儿子在学java");
}
//1,子类 可以继承父类的方法们 还可以扩展自己的功能
public void sleep() {
System.out.println("sleep()...");
}
}
--3,构造方法
package cn.tedu.oop;
//测试 继承构造方法 的使用
//总结
//1,子类的构造方法里,默认就会存在super()--去调用父类的 无参构造
//2,当创建子类对象时, 先执行 父类的构造方法 , 再执行 子类的构造方法
public class Test3_Extends3 {
public static void main(String[] args) {
//3,创建子类对象测试
new Zi3();//会先去执行父类的无参构造,再执行自己的
}
}
class Fu3{
//4,如果父类没提供无参构造(也就是只提供了含参构造)
// public Fu3() {
// System.out.println("父类的 无参构造");
// }
public Fu3(int a) {
System.out.println("父类的 含参构造"+a);
}
}
class Zi3 extends Fu3{
public Zi3() {
//1,在子类的构造方法中,会隐藏着一行代码super()
// super();//2,会自动执行父类的无参构造--如果父类不提供无参构造会报错
//5,调用 父类的 含参构造?
super(10);//6,当super关键字,出现在构造方法里时,位置必须是第一条语句
System.out.println("子类的 无参构造");
}
}二,static关键字
–1,特点
–可以修饰成员变量，成员方法
–可以直接被类名调用
–随着类的加载而加载，优先于对象加载
–只加载一次，就会一直存在，不再开辟新空间
–全局唯一，全局共享
–static不能和this或者super共用，因为有static时可能还没有对象
–静态只能调用静态，非静态可以随意调用
–2,测试
package cn.tedu.oop;
//测试 静态关键字
//总结:
//1,静态的调用关系—静态只能调用静态–非静态调用啥资源都可以
//2,静态资源是加载非常早的,随着类的加载就已经加载进内存了,比对象早
//3,静态资源的访问方式:通过对象调用 + 通过类名调用
public class Test4_Static {
public static void main(String[] args) {
//2,静态资源优先于对象加载,因为是随着类的加载就已经加载了
Student.coding();
System.out.println(Student.name);Student s = new Student();
s.study();
System.out.println(s.age);
//1,静态资源,多了一种访问方式,除了可以用对象访问,更提倡用类名直接调用
// s.coding();
// System.out.println(s.name);
Student.coding();
System.out.println(Student.name);
//3,静态资源是共享资源,能够被多个对象共享
Student s1 = new Student();
s1.name="陈子枢";
Student s2 = new Student();
System.out.println(s2.name);//陈子枢
}
}
class Student{
//普通资源
int age = 10;
public void study() {
//6,非静态调用关系? -- 调用任意资源
System.out.println(age);
System.out.println(name);
coding();
System.out.println("正在学习java");
}
//静态资源
static String name ;
static public void coding() {
//4,静态资源里,不能使用this或者super关键字!
// this.study();
// super.
//5,静态调用关系? -- 只能调用静态,不能调用非静态的
System.out.println(name);
// study();
System.out.println("正在敲代码");
}
}三,static代码块
–1,一段被花括号包起来的代码,而且被static修饰
static{…}
–2,位置是在成员位置,也拥有static关键字的特点
–3,测试
package cn.tedu.oop;
//测试 代码块
//1,静态代码块:用来初始化项目–位置在成员位置
//2,执行顺序:
//类加载时 : 静态代码块
//实例化时 : 构造代码块 > 构造方法
//方法调用时 : 局部代码块
public class Test5_Block {
public static void main(String[] args) {
StaticDemo s = new StaticDemo();//先执行构造代码块然后执行构造方法
s.show();//执行局部代码块StaticDemo s2 = new StaticDemo();
}
}
class StaticDemo{
//静态代码块--位置也是在成员位置--用来完成项目的初始化
//--只加载一次，在类第一次被加载时就跟着一起加载了(类的资源)
static{
System.out.println("静态代码块");
}
//构造代码块--位置是在成员位置--用来提取构造方法的共性
{
System.out.println("构造代码块");
}
//构造方法
public StaticDemo() {
System.out.println("构造方法");
}
//局部代码块--位置是在方法里--用来控制变量的作用范围
public void show() {
{
System.out.println("局部代码块");
}
}
}四,final关键字
–1,让子类的重写权限变得可控.如果父类的某个方法不让子类重写,可以用final修饰变成最终方法
–2,表示最终的意思.可以修饰类,成员变量,成员方法
–3,测试
package cn.tedu.oop;
//测试 final关键字
//1,final 修饰的类是最终的类,不能被继承
//2,final 修饰的变量,是一个最终的变量,值不能被修改,称之为是常量
//3,final 修饰的方法,不能被重写
public class Test6_Final {
public static void main(String[] args) {
//创建子类对象测试
Son s = new Son();
s.eat();
// s.sum = 20 ;//final前可以改也能使用
System.out.println(s.SUM);
}
}
//1,final修饰的类是最终的类,不能被继承–The type Son cannot subclass the final class Father
//final class Father{
class Father {
//3,final 修饰的变量,final用来修饰常量–The final field Father.sum cannot be assigned
// final int sum = 10 ;
static final int SUM = 10 ;
//2,final 修饰的方法,只能用不能被重写–Cannot override the final method from Father
final public void eat() {
System.out.println(“Father…eat()”);
}
}
class Son extends Father{
// //想要改,发生了重写!!
// public void eat() {
// System.out.println(“Son…eat()”);
// }
}五,多态
–1,就是指同一个对象,在不同时刻,代表的对象不同.就是指同一个对象的多种形态.
–2,多态的作用 – 用来统一调用标准!!! 一切向父类看齐
–3,好处是 : 做出通用编程,本质上就是不关心具体的子类的类型,屏蔽了子类之间的不同,可以把 子类当做父类来看.
–4,特点
–前提: 继承关系 + 方法的重写
–5,测试
package cn.tedu.oop;
//测试 多态
public class Test7_Multi {
public static void main(String[] args) {
//创建子类对象测试
new Dog().eat();//重写前执行父类的,重写后执行子类的
//创建多态对象测试
Animal a = new Dog();//口诀1:父类引用 指向 子类对象
//口诀2:编译看左边,运行看右边
//编译看左边–是指想要保存成功,向左边也就是 向父类看齐–统一标准!!
//运行看右边–是指结果向右边看齐也就是看子类的干活结果
a.eat();//狗吃肉
// a.test();//test()是子类的特有方法,多态对象只能调用 父类的
}
}
class Animal{
public void eat() {
System.out.println(“啥都吃”);
}
}
//1,多态的前提:继承 + 方法重写(方法声明和父类一样)
class Dog extends Animal{
public void eat() {
System.out.println(“狗吃肉”);
}
public void test() {
System.out.println(“test…”);
}
}六,多态的使用
–1,成员变量
–2,成员方法
–3,静态成员
–4,测试
package cn.tedu.oop;
//测试 多态的使用
//总结
//1,多态中,的成员变量 – 用父类的
//2,多态中,的成员方法 – 用父类的方法声明,用子类的方法体
//TODO 3,多态中 ,的 静态资源?
public class Test8_UseMulti {
public static void main(String[] args) {
//创建多态对象–父类引用 指向 子类对象
Fu4 fu = new Zi4();
//编译看左边,运行看右边
System.out.println( fu.name );//成员变量用谁的?–父类的
//多态中,方法声明用–父类的 ,方法体用–子类的(因为重写了)
fu.show();//成员方法用谁的?–子类的(重写了)
fu.test();//成员方法用谁的?–父类的(没重写)
}
}
class Fu4{
String name = “尼古拉斯.赵四” ;
public void show() {
System.out.println(“Fu4…show()”);
}
final public void test() {//被final了,不让子类重写了!
System.out.println(“Fu4…test()”);
}
}
class Zi4 extends Fu4{
String name = “Anglelababa”;
public void show() {
System.out.println(“Zi4…show()”);
}
}- java文件的运行过程 一,继承的使用 –1,成员变量
• package cn.tedu.oop;
// 测试 继承成员变量 的使用
//总结 : 在子类中,想用父类的成员变量
//1,子类和父类的变量名不相同时,可以省略super.
//2,子类和父类的变量名相同,必须用super来调用父类的资源,不能省略
public class Test1_Extends {
public static void main(String[] args) {
new Zi().show();
}
}
class Fu{
int count = 10;
int sum = 30 ;
}
class Zi extends Fu{
int num ;
int sum = 20 ;public void show() {
int sum = 10 ;
System.out.println(sum);//10,就近原则
System.out.println(num);//0,使用了默认值
System.out.println(this.sum);//this能够调用本类的成员变量
//1,super代表父类对象的引用.可以在子类中,使用父类的内容
//2,相当于super帮你创建了一个父类对象,Fu super = new Fu();
System.out.println(super.count);//10,用了父类的 不同名的变量,可以省略super.
System.out.println(super.sum);//30,用了父类的,和子类同名了
}
}–2,成员方法
package cn.tedu.oop;
//测试 继承成员方法 的使用
//1,子类 可以继承父类的方法们 – 可以直接使用
//2,子类 可以进行扩展 – 可以直接使用
//3,子类 可以修改继承来的方法 – 方法的重写override
//4,什么时候需要重写?–想要改时!!!
public class Test2_Extends2 {
public static void main(String[] args) {
//4,创建子类对象测试
Zi2 zi = new Zi2();
zi.eat();//重写前,使用了父类的,重写后,使用子类的
zi.study();//重写前,使用了父类的,重写后,使用子类的
zi.sleep();//子类特有的
}
}
class Fu2{
public void eat() {
System.out.println(“爸爸在吃猪肉”);
}
public void study() {
System.out.println(“爸爸在学搓麻”);
}
}
class Zi2 extends Fu2{
//2,子类可以把父类的所有方法都继承来使用,也可以修改(方法重写)
//要求:继承+子类的方法声明和父类必须一样
public void eat() {
//3,调用父类原来的eat()–重写并不会影响父类的原有功能
// super.eat();
System.out.println(“儿子在吃菜”);
}
public void study() {
System.out.println(“儿子在学java”);
}
//1,子类 可以继承父类的方法们 还可以扩展自己的功能
public void sleep() {
System.out.println(“sleep()…”);
}–3,构造方法
package cn.tedu.oop;
//测试 继承构造方法 的使用
//总结
//1,子类的构造方法里,默认就会存在super()–去调用父类的 无参构造
//2,当创建子类对象时, 先执行 父类的构造方法 , 再执行 子类的构造方法
public class Test3_Extends3 {
public static void main(String[] args) {
//3,创建子类对象测试
new Zi3();//会先去执行父类的无参构造,再执行自己的
}
}
class Fu3{
//4,如果父类没提供无参构造(也就是只提供了含参构造)
// public Fu3() {
// System.out.println(“父类的 无参构造”);
// }
public Fu3(int a) {
System.out.println(“父类的 含参构造”+a);
}
}
class Zi3 extends Fu3{
public Zi3() {
//1,在子类的构造方法中,会隐藏着一行代码super()
// super();//2,会自动执行父类的无参构造–如果父类不提供无参构造会报错
//5,调用 父类的 含参构造?
super(10);//6,当super关键字,出现在构造方法里时,位置必须是第一条语句
System.out.println(“子类的 无参构造”);
}二,static关键字
–1,特点
–可以修饰成员变量，成员方法
–可以直接被类名调用
–随着类的加载而加载，优先于对象加载
–只加载一次，就会一直存在，不再开辟新空间
–全局唯一，全局共享
–static不能和this或者super共用，因为有static时可能还没有对象
–静态只能调用静态，非静态可以随意调用
–2,测试
package cn.tedu.oop;
//测试 静态关键字
//总结:
//1,静态的调用关系—静态只能调用静态–非静态调用啥资源都可以
//2,静态资源是加载非常早的,随着类的加载就已经加载进内存了,比对象早
//3,静态资源的访问方式:通过对象调用 + 通过类名调用
public class Test4_Static {
public static void main(String[] args) {
//2,静态资源优先于对象加载,因为是随着类的加载就已经加载了
Student.coding();
System.out.println(Student.name);Student s = new Student();
s.study();
System.out.println(s.age);
//1,静态资源,多了一种访问方式,除了可以用对象访问,更提倡用类名直接调用
// s.coding();
// System.out.println(s.name);
Student.coding();
System.out.println(Student.name);
//3,静态资源是共享资源,能够被多个对象共享
Student s1 = new Student();
s1.name="陈子枢";
Student s2 = new Student();
System.out.println(s2.name);//陈子枢
}
}
class Student{
//普通资源
int age = 10;
public void study() {
//6,非静态调用关系? -- 调用任意资源
System.out.println(age);
System.out.println(name);
coding();
System.out.println("正在学习java");
}
//静态资源
static String name ;
static public void coding() {
//4,静态资源里,不能使用this或者super关键字!
// this.study();
// super.
//5,静态调用关系? -- 只能调用静态,不能调用非静态的
System.out.println(name);
// study();
System.out.println("正在敲代码");
}
}三,static代码块
–1,一段被花括号包起来的代码,而且被static修饰
static{…}
–2,位置是在成员位置,也拥有static关键字的特点
–3,测试
package cn.tedu.oop;
//测试 代码块
//1,静态代码块:用来初始化项目–位置在成员位置
//2,执行顺序:
//类加载时 : 静态代码块
//实例化时 : 构造代码块 > 构造方法
//方法调用时 : 局部代码块
public class Test5_Block {
public static void main(String[] args) {
StaticDemo s = new StaticDemo();//先执行构造代码块然后执行构造方法
s.show();//执行局部代码块StaticDemo s2 = new StaticDemo();
}
}
class StaticDemo{
//静态代码块--位置也是在成员位置--用来完成项目的初始化
//--只加载一次，在类第一次被加载时就跟着一起加载了(类的资源)
static{
System.out.println("静态代码块");
}
//构造代码块--位置是在成员位置--用来提取构造方法的共性
{
System.out.println("构造代码块");
}
//构造方法
public StaticDemo() {
System.out.println("构造方法");
}
//局部代码块--位置是在方法里--用来控制变量的作用范围
public void show() {
{
System.out.println("局部代码块");
}
}
}四,final关键字
–1,让子类的重写权限变得可控.如果父类的某个方法不让子类重写,可以用final修饰变成最终方法
–2,表示最终的意思.可以修饰类,成员变量,成员方法
–3,测试
package cn.tedu.oop;
//测试 final关键字
//1,final 修饰的类是最终的类,不能被继承
//2,final 修饰的变量,是一个最终的变量,值不能被修改,称之为是常量
//3,final 修饰的方法,不能被重写
public class Test6_Final {
public static void main(String[] args) {
//创建子类对象测试
Son s = new Son();
s.eat();
// s.sum = 20 ;//final前可以改也能使用
System.out.println(s.SUM);
}
}
//1,final修饰的类是最终的类,不能被继承–The type Son cannot subclass the final class Father
//final class Father{
class Father {
//3,final 修饰的变量,final用来修饰常量–The final field Father.sum cannot be assigned
// final int sum = 10 ;
static final int SUM = 10 ;
//2,final 修饰的方法,只能用不能被重写–Cannot override the final method from Father
final public void eat() {
System.out.println(“Father…eat()”);
}
}
class Son extends Father{
// //想要改,发生了重写!!
// public void eat() {
// System.out.println(“Son…eat()”);
// }
}五,多态
–1,就是指同一个对象,在不同时刻,代表的对象不同.就是指同一个对象的多种形态.
–2,多态的作用 – 用来统一调用标准!!! 一切向父类看齐
–3,好处是 : 做出通用编程,本质上就是不关心具体的子类的类型,屏蔽了子类之间的不同,可以把 子类当做父类来看.
–4,特点
–前提: 继承关系 + 方法的重写
–5,测试
package cn.tedu.oop;
//测试 多态
public class Test7_Multi {
public static void main(String[] args) {
//创建子类对象测试
new Dog().eat();//重写前执行父类的,重写后执行子类的
//创建多态对象测试
Animal a = new Dog();//口诀1:父类引用 指向 子类对象
//口诀2:编译看左边,运行看右边
//编译看左边–是指想要保存成功,向左边也就是 向父类看齐–统一标准!!
//运行看右边–是指结果向右边看齐也就是看子类的干活结果
a.eat();//狗吃肉
// a.test();//test()是子类的特有方法,多态对象只能调用 父类的
}
}
class Animal{
public void eat() {
System.out.println(“啥都吃”);
}
}
//1,多态的前提:继承 + 方法重写(方法声明和父类一样)
class Dog extends Animal{
public void eat() {
System.out.println(“狗吃肉”);
}
public void test() {
System.out.println(“test…”);
}
}六,多态的使用
–1,成员变量
–2,成员方法
–3,静态成员
–4,测试
package cn.tedu.oop;
//测试 多态的使用
//总结
//1,多态中,的成员变量 – 用父类的
//2,多态中,的成员方法 – 用父类的方法声明,用子类的方法体
//TODO 3,多态中 ,的 静态资源?
public class Test8_UseMulti {
public static void main(String[] args) {
//创建多态对象–父类引用 指向 子类对象
Fu4 fu = new Zi4();
//编译看左边,运行看右边
System.out.println( fu.name );//成员变量用谁的?–父类的
//多态中,方法声明用–父类的 ,方法体用–子类的(因为重写了)
fu.show();//成员方法用谁的?–子类的(重写了)
fu.test();//成员方法用谁的?–父类的(没重写)
}
}
class Fu4{
String name = “尼古拉斯.赵四” ;
public void show() {
System.out.println(“Fu4…show()”);
}
final public void test() {//被final了,不让子类重写了!
System.out.println(“Fu4…test()”);
}
}
class Zi4 extends Fu4{
String name = “Anglelababa”;
public void show() {
System.out.println(“Zi4…show()”);
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
