Java（10）面向对象之继承，内部类
2024-05-18 00:10:15
01 面向对象之继承
public class Inheritance02 {public class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;}public class Boy extends Person{}public class Girl extends Person{}
}
02 面向对象之继承代码实现
public class Inheritance03 {public static class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {}public Person(String nickname, int gender, int age) {this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}public static class Boy extends Person {}public static class Girl extends Person {}
}
import Inheritance03;
import org.junit.jupiter.api.Test;public class Inheritance03Test {@Testpublic void test01() {Inheritance03.Person person = new Inheritance03.Person("姓名", 1, 999);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
姓名 >>> 姓名
性别 >>> 小伙儿
年龄 >>> 999*/@Testpublic void test02() {Inheritance03.Boy person = new Inheritance03.Boy();person.setNickname("姓名");person.setGender(1);person.setAge(20);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
姓名 >>> 姓名
性别 >>> 小伙儿
年龄 >>> 20*/@Testpublic void test03() {Inheritance03.Girl person = new Inheritance03.Girl();person.setNickname("姓名");person.setGender(0);person.setAge(28);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
姓名 >>> 姓名
性别 >>> 老妹儿
年龄 >>> 18*
}
03 super关键字
public class Inheritance04 {public static class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {}public Person(String nickname, int gender, int age) {this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}public static class Boy extends Person {public Boy() {}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);}}public static class Girl extends Person {public Girl() {}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);}}
}
import Inheritance04;
import org.junit.jupiter.api.Test;public class Inheritance04Test {@Testpublic void test01() {Inheritance04.Person person = new Inheritance04.Person("姓名", 1, 999);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
姓名 >>> 姓名
性别 >>> 小伙儿
年龄 >>> 999*/@Testpublic void test02() {Inheritance04.Boy person = new Inheritance04.Boy("姓名", 1, 20);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
姓名 >>> 姓名
性别 >>> 小伙儿
年龄 >>> 20*/@Testpublic void test03() {Inheritance04.Girl person = new Inheritance04.Girl("姓名", 0, 18);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
姓名 >>> 姓名
性别 >>> 老妹儿
年龄 >>> 18*/
}
04 子父类实例化顺序
public class Inheritance05 {public static class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {System.out.println("我是Person类的无参构造方法");}public Person(String nickname, int gender, int age) {System.out.println("我是Person类的有参构造方法");this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}public static class Boy extends Person {public Boy() {System.out.println("我是Boy类的无参构造方法");}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Boy类的有参构造方法");}}public static class Girl extends Person {public Girl() {System.out.println("我是Girl类的无参构造方法");}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Girl类的有参构造方法");}}
}
import Inheritance05;
import org.junit.jupiter.api.Test;public class Inheritance05Test {@Testpublic void test01() {Inheritance05.Person person = new Inheritance05.Person("创世之神", 1, 999);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
姓名 >>> 创世之神
性别 >>> 小伙儿
年龄 >>> 999*/@Testpublic void test02() {Inheritance05.Boy person = new Inheritance05.Boy("姓名", 1, 20);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
我是Person类的有参构造方法
我是Boy类的有参构造方法
姓名 >>> 姓名
性别 >>> 小伙儿
年龄 >>> 20*/@Testpublic void test03() {Inheritance05.Girl person = new Inheritance05.Girl("姓名", 0, 18);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
我是Person类的有参构造方法
我是Girl类的有参构造方法
姓名 >>> 姓名
性别 >>> 老妹儿
年龄 >>> 18*/
}
05 父类的引用指向子类的实例化对象
public class Inheritance06 {public static class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {System.out.println("我是Person类的无参构造方法");}public Person(String nickname, int gender, int age) {System.out.println("我是Person类的有参构造方法");this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}public static class Boy extends Person {public Boy() {System.out.println("我是Boy类的无参构造方法");}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Boy类的有参构造方法");}}public static class Girl extends Person {public Girl() {System.out.println("我是Girl类的无参构造方法");}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Girl类的有参构造方法");}}
}import Inheritance06;
import org.junit.jupiter.api.Test;public class Inheritance06Test {@Testpublic void test01() {Inheritance06.Person person = new Inheritance06.Person("创世之神", 1, 10000);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}
/*
我是Person类的有参构造方法
姓名 >>> 创世之神
性别 >>> 小伙儿
年龄 >>> 10000
*/@Testpublic void test02() {Inheritance06.Person person = new Inheritance06.Boy("姓名", 1, 20);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}
/*
我是Person类的有参构造方法
我是Boy类的有参构造方法
姓名 >>> 姓名
性别 >>> 小伙儿
年龄 >>> 20
*/@Testpublic void test03() {Inheritance06.Person person = new Inheritance06.Girl("姓名", 0, 18);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}/*
我是Person类的有参构造方法
我是Girl类的有参构造方法
姓名 >>> 姓名
性别 >>> 老妹儿
年龄 >>> 18*/
}
06 子类可以拥有单独的方法，无法直接调用子类中的方法
public class Inheritance07 {public static class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {System.out.println("我是Person类的无参构造方法");}public Person(String nickname, int gender, int age) {System.out.println("我是Person类的有参构造方法");this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}public static class Boy extends Person {public Boy() {System.out.println("我是Boy类的无参构造方法");}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Boy类的有参构造方法");}public void work(){System.out.println("看这边都是朕为你打下江山");}}public static class Girl extends Person {public Girl() {System.out.println("我是Girl类的无参构造方法");}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Girl类的有参构造方法");}public void beauty() {System.out.println("男人征服了世界，而女人征服了男人");}}
}
import Inheritance07;
import org.junit.jupiter.api.Test;public class Inheritance07Test {@Testpublic void test01() {Inheritance07.Person person = new Inheritance07.Person("创世之神", 1, 10000);System.out.println("姓名 >>> " + person.getNickname());System.out.println("性别 >>> " + (person.getGender() == 1 ? "小伙儿" : "老妹儿"));System.out.println("年龄 >>> " + person.getAge());}
/*
我是Person类的有参构造方法
姓名 >>> 创世之神
性别 >>> 小伙儿
年龄 >>> 10000
*/@Testpublic void test02() {Inheritance07.Boy boy = new Inheritance07.Boy();boy.work();Inheritance07.Person person = new Inheritance07.Boy("姓名", 1, 20);// person.work();}
/*
我是Person类的无参构造方法
我是Boy类的无参构造方法
看这边都是朕为你打下江山
我是Person类的有参构造方法
我是Boy类的有参构造方法
*/@Testpublic void test03() {Inheritance07.Girl girl = new Inheritance07.Girl();girl.beauty();Inheritance07.Person person = new Inheritance07.Girl("姓名", 0, 18);// person.beauty();}/*
我是Person类的无参构造方法
我是Girl类的无参构造方法
男人征服了世界，而女人征服了男人
我是Person类的有参构造方法
我是Girl类的有参构造方法*/
}
07 方法重写
public class Inheritance08 {public static class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {System.out.println("我是Person类的无参构造方法");}public Person(String nickname, int gender, int age) {System.out.println("我是Person类的有参构造方法");this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void eat() {System.out.println("吃吃吃");}}public static class Boy extends Person {public Boy() {System.out.println("我是Boy类的无参构造方法");}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Boy类的有参构造方法");}public void work(){System.out.println("看这边都是朕为你打下江山");}}public static class Girl extends Person {public Girl() {System.out.println("我是Girl类的无参构造方法");}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Girl类的有参构造方法");}public void beauty() {System.out.println("男人征服了世界，而女人征服了男人");}}
}
import Inheritance08;
import org.junit.jupiter.api.Test;public class Inheritance08Test {@Testpublic void test01() {Inheritance08.Person person = new Inheritance08.Person("创世之神", 1, 10000);person.eat();}
/*
我是Person类的有参构造方法
吃吃吃
*/@Testpublic void test02() {Inheritance08.Boy boy = new Inheritance08.Boy();boy.work();boy.eat();Inheritance08.Person person = new Inheritance08.Boy("姓名", 1, 20);person.eat();}
/*
我是Person类的无参构造方法
我是Boy类的无参构造方法
看这边都是朕为你打下江山
吃吃吃
我是Person类的有参构造方法
我是Boy类的有参构造方法
吃吃吃
*/@Testpublic void test03() {Inheritance08.Girl girl = new Inheritance08.Girl();girl.beauty();girl.eat();Inheritance08.Person person = new Inheritance08.Girl("姓名", 0, 18);person.eat();}/*
我是Person类的无参构造方法
我是Girl类的无参构造方法
男人征服了世界，而女人征服了男人
吃吃吃
我是Person类的有参构造方法
我是Girl类的有参构造方法
吃吃吃*/
}
08 方法重写与方法重载
/*** 方法重载：在同一个类中 方法参数列表不同的同名方法 这种表现形式我们称之为方法重载* 方法重写：当父类的方法满足不了子类的需求 子类可以重写父类的方法 这种表现形式我们称之为方法重写* 二者区别 方法重载是同一个类中 而方法重写必须存在子父类继承关系*/
public class Inheritance09 {public static class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {System.out.println("我是Person类的无参构造方法");}public Person(String nickname, int gender, int age) {System.out.println("我是Person类的有参构造方法");this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void eat() {System.out.println("吃吃吃");}}public static class Boy extends Person {public Boy() {System.out.println("我是Boy类的无参构造方法");}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Boy类的有参构造方法");}public void work(){System.out.println("看这边都是朕为你打下江山");}@Overridepublic void eat() {System.out.println("吃核桃");}}public static class Girl extends Person {public Girl() {System.out.println("我是Girl类的无参构造方法");}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Girl类的有参构造方法");}public void beauty() {System.out.println("男人征服了世界，而女人征服了男人");}@Overridepublic void eat() {System.out.println("吃荔枝");}}
}
import Inheritance09;
import org.junit.jupiter.api.Test;/*** 父类的引用指向子类的实例化对象*/
public class Inheritance09Test {@Testpublic void test01() {Inheritance09.Person person = new Inheritance09.Person("创世之神", 1, 10000);person.eat();}
/*
我是Person类的有参构造方法
吃吃
*/@Testpublic void test02() {Inheritance09.Boy boy = new Inheritance09.Boy();boy.work();boy.eat();Inheritance09.Person person = new Inheritance09.Boy("姓名", 1, 20);person.eat();}
/*
我是Person类的无参构造方法
我是Boy类的无参构造方法
看这边都是朕为你打下江山
吃核桃
我是Person类的有参构造方法
我是Boy类的有参构造方法
吃核桃
*/@Testpublic void test03() {Inheritance09.Girl girl = new Inheritance09.Girl();girl.beauty();girl.eat();Inheritance09.Person person = new Inheritance09.Girl("姓名", 0, 18);person.eat();}/*
我是Person类的无参构造方法
我是Girl类的无参构造方法
男人征服了世界，而女人征服了男人
吃荔枝
我是Person类的有参构造方法
我是Girl类的有参构造方法
吃荔枝*/
}
09 向上转型与向下转型
/*** 方法重载：在同一个类中 方法参数列表不同的同名方法 这种表现形式我们称之为方法重载* 方法重写：当父类的方法满足不了子类的需求 子类可以重写父类的方法 这种表现形式我们称之为方法重写* 二者区别 方法重载是同一个类中 而方法重写必须存在子父类继承关系*/
public class Inheritance10 {public static class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {System.out.println("我是Person类的无参构造方法");}public Person(String nickname, int gender, int age) {System.out.println("我是Person类的有参构造方法");this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void eat() {System.out.println("吃吃吃");}}public static class Boy extends Person {public Boy() {System.out.println("我是Boy类的无参构造方法");}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Boy类的有参构造方法");}public void work(){System.out.println("看这边都是朕为你打下江山");}@Overridepublic void eat() {System.out.println("吃核桃");}}public static class Girl extends Person {public Girl() {System.out.println("我是Girl类的无参构造方法");}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Girl类的有参构造方法");}public void beauty() {System.out.println("男人征服了世界，而女人征服了男人");}@Overridepublic void eat() {System.out.println("吃荔枝");}}
}
import Inheritance10;
import org.junit.jupiter.api.Test;/*** 父类的引用指向子类的实例化对象 向上转型*/
public class Inheritance10Test {@Testpublic void test01() {Inheritance10.Person person = new Inheritance10.Person("创世之神", 1, 10000);person.eat();// 向下转型 注意 只有该对象本身就是子类类型的时候向下转型才会成功Inheritance10.Boy boy = (Inheritance10.Boy) person;//java.lang.ClassCastException: class Day13.Inheritance10$Person cannot be cast to class Day13.Inheritance10$Boy (Day13.Inheritance10$Person and Day13.Inheritance10$Boy are in unnamed module of loader 'app')// boy.eat();}
/*
我是Person类的有参构造方法
吃吃吃
*/@Testpublic void test02() {// 父类的引用指向子类的实例化对象 向上转型 向上转型自动转Inheritance10.Boy person = new Inheritance10.Boy("李昊哲", 1, 40);person.eat();// person.work();// 向下转型Inheritance10.Boy boy = person;boy.eat();boy.work();}
/*
我是Person类的有参构造方法
我是Boy类的有参构造方法
吃核桃
吃核桃
看这边都是朕为你打下江山
*/@Testpublic void test03() {Inheritance10.Person person = new Inheritance10.Girl("李哲", 0, 28);person.eat();// 向下转型Inheritance10.Girl girl = (Inheritance10.Girl) person;girl.eat();girl.beauty();}/*
我是Person类的有参构造方法
我是Girl类的有参构造方法
吃荔枝
吃荔枝
男人征服了世界，而女人征服了男人*/
}
10 final修饰类和方法
/*** 方法重载：在同一个类中 方法参数列表不同的同名方法 这种表现形式我们称之为方法重载* 方法重写：当父类的方法满足不了子类的需求 子类可以重写父类的方法 这种表现形式我们称之为方法重写* 二者区别 方法重载是同一个类中 而方法重写必须存在子父类继承关系** final 修饰的类无法被继承* final 修饰的方法无法被重写*/
public class Inheritance11 {public class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;public Person() {System.out.println("我是Person类的无参构造方法");}public Person(String nickname, int gender, int age) {System.out.println("我是Person类的有参构造方法");this.nickname = nickname;this.gender = gender;this.age = age;}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGender() {return gender;}public void setGender(int gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void eat() {System.out.println("吃吃吃");}}public class Boy extends Person {public Boy() {System.out.println("我是Boy类的无参构造方法");}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Boy类的有参构造方法");}public void work(){System.out.println("看这边都是朕为你打下江山");}@Overridepublic void eat() {System.out.println("吃核桃");}}public class Girl extends Person {public Girl() {System.out.println("我是Girl类的无参构造方法");}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);System.out.println("我是Girl类的有参构造方法");}public void beauty() {System.out.println("男人征服了世界，而女人征服了男人");}@Overridepublic void eat() {System.out.println("吃荔枝");}}
}
11 方法重写与方法重载综合例子
public class InheritanceTest {public static void main(String[] args) {Goo goo = new Goo();Super s = new Sub();goo.g(s);// 输出结果：g(Super).. Sub.f()// 重载看类型 重写看对象// 眼睛就是显示器 大脑就是编译器}/*
g(Super)..
Sub.f()*/
}class Super {public void f() {System.out.println("Super.f()");}
}class Sub extends Super {@Overridepublic void f() {System.out.println("Sub.f()");}
}class Goo {public void g(Super obj) {System.out.println("g(Super)..");obj.f();}public void g(Sub obj) {System.out.println("g(Sub)..");obj.f();}
}
12 匿名内部类
package Inner;public class Outer01 {public static class Inner{public static Object Outer01;public static void run(){System.out.println("加油吧少年");}}
}
package Inner;public class Outer02 {public class Inner{public static Object Outer02;public static void run(){System.out.println("加油吧少年");}}
}
package Inner;public class Outer03 {public class Inner{public void run(){System.out.println("加油吧少年");}}
}
package Inner;public class Outer04 {public class Inner {public void run() {System.out.println("加油吧少年");}}public void innerRun() {new Inner().run();}
}
package Inner;public class Outer05 {public static void innerRun() {class Inner {public static void run() {System.out.println("加油吧少年");}}Inner.run();}
}
package Inner;public class Outer06 {public static void innerRun() {class Inner {public void run() {System.out.println("加油吧少年");}}new Inner().run();}
}
package Inner;public class Outer07 {public void innerRun() {class Inner {public void run() {System.out.println("加油吧少年");}}new Inner().run();}
}
package Inner;public class Outer08 {public void innerRun() {class Inner{}new Inner(){public void run(){System.out.println("加油吧少年");}};}
}
package Inner;public class Outer09 {public void innerRun() {class Inner{}new Inner(){public void run(){System.out.println("加油吧少年");}}.run();}
}
package Inner;public class Outer10 {public void innerRun() {new Object(){public void run(){System.out.println("加油吧少年");}}.run();}
}
import Day13Inner.*;
import org.junit.jupiter.api.Test;/*** @author 王庆* @version 1.0.0 2022/4/24 下午8:05*/
public class Day13InnerTest {@Testpublic void outer01(){Outer01.Inner.run();}//加油吧少年@Testpublic void outer02(){Outer02.Inner.run();}//加油吧少年@Testpublic void outer03(){new Outer03().new Inner().run();}//加油吧少年@Testpublic void outer04(){new Outer04().innerRun();}//加油吧少年@Testpublic void outer05(){Outer05.innerRun();}//加油吧少年@Testpublic void outer06(){Outer06.innerRun();}//加油吧少年@Testpublic void outer07(){new Outer07().innerRun();}/加油吧少年@Testpublic void outer08(){new Outer08().innerRun();}//@Testpublic void outer09(){new Outer09().innerRun();}//加油吧少年@Testpublic void outer10(){new Outer10().innerRun();}//加油吧少年
}
Java（10）面向对象之继承，内部类相关推荐
- java入门 -- 面向对象关键字及内部类
1 static 我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下,某些特定的数据在内存空间里只有一份,例如所有的中国人都有个国家名称,每一个中国人都共享这个国家名称,不必在每一个中国人的 ...
- java之面向对象：继承extends、super、覆盖override的用法
继承的好处: 1 )提高了代码的复用性. 2 )让类与类之间产生了关系,给第三个特征多态提供 了前提. java支持单继承,不直接支持多继承,但对C++中的多继承机制进行改良. 单继承:一个子类只能有 ...
- Java 10 常用集合继承关系图
概述 集合类存放的都是对象的引用,而非对象本身,出于表达上的便利,我们称集合中的对象就是指集合中对象的引用. 类图如下: 1.Iterable与Iterator接口之间的区别 我看到好多网上的文章类图 ...
- Java基础-面向对象第二特征之继承（Inheritance）
Java基础-面向对象第二特征之继承(Inheritance) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.继承的概述 在现实生活中,继承一般指的是子女继承父辈的财产.在程序 ...
- java用继承编写宠物乐园_MoreThanJavaDay 5：面向对象进阶继承详解
「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...
- Java面向对象（继承、抽象类）
面向对象 今日内容介绍 u 继承 u 抽象类 第1章 继承 1.1 继承的概念 在现实生活中,继承一般指的是子女继承父辈的财产.在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成 ...
- 【小白学java】java的面向对象设计：封装+继承+抽象类+接口（day06）
课程链接:共六天 第一天:开发环境:初识java,搭建环境 第二天:语言基础:关键字.变量.常量.运算符 第三天:数据结构:基本类型.包装类型.引用类型(数组和对象) 第四天:流程控制:分支判断.循环 ...
- java面向对象基础——继承、抽象类
一.继承 1.继承概述 为什么会有继承? 现实生活中,为什么要有继承? 程序中,为什么要有继承? 继承的含义 继承:在java中指的是"一个类"可以"继承自"& ...
- Java面向对象：继承
面向对象三大特征之二:继承 目录 面向对象三大特征之二:继承 1.继承是什么: 2.继承的好处 继承概述的总结 1.什么是继承?继承有什么好处? 2.继承的格式是什么样的? 3.继承后子类的特点是什么 ...
最新文章
- 更新pcb封装导入_一导入PCB就出问题？赶紧看看这篇文章
- 历届试题 错误票据（multiset）
- js中的scroll和offset 的使用比较
- 手机计算机数据消失了怎么恢复,电脑突然黑屏闪退之后怎么恢复丢失的数据
- 桥梁在线计算机监测系统,桥梁在线监测系统
- 微软为 Java 开发者推出 VSCode 安装程序
- 机器学习与计算机视觉（移动端深度学习优化框架）
- java aws批量_通过 S3 Batch Operations (批量操作)功能轻松处理海量对象
- git克隆权限_git clone权限被拒绝
- Unable to start ServletWebServerApplicationContext due to missing ServletWebServerFactory bean.
- html 调用es2015模块,现在，在项目中直接部署ES2015+代码吧！
- flash player 11.2 64位 linux,Flash Player 11.2新版发布
- layui前端项目打包方法_layui封装模块基础教程
- 梅科尔工作室深度学习第五课-CNN
- 小黑静待身边朋友的考研佳音，明天准备面试，在白塔咖啡帐篷里的一下午的leetcode之旅:70. 爬楼梯
- 苹果手机home键在哪里_苹果手机为什么没有返回键? 原来隐藏着更好的方法, 涨知识了...
- FPGA概念理解之：ZYNQ、PS、PL、APU、ARM、SOC、URAT、GPIO...
- OPTICS聚类以及python实现
- 小米6鲁大师html5评测,小米6跑分超110万？鲁大师官方：网友PS的图片
- 网络安全自学笔记+学习路线（超详细）