1.继承 : 子承父业
目的 : 提高代码的复用性
作用: 子类一旦继承父类,有权使用父类中的成员,可以在子类中定义子类独有的内容
定义: 子类 extends 父类
实体类|子类 : 根据一系列对象抽取共性所定义的实体类
父类 : 子类的共性
子类| 派生类
父类 | 基类 | 超类
特点 : 单继承机制 ,一个子类只能继承一个父类,但是一个父类可以存在多个子类
修饰类只能使用public|default(默认)
开闭原则--> 面试对象设计原则之一 : 对修改关闭,对扩展开放
单继承的优点 : 简单
单继承的缺点 : 不便于后期维护
public class Class001_Extends {
public static void main(String[] args) {
Teacher t = new Teacher();
t.name = "马云";
t.age = 50;
t.subject = "英语";
t.teach();
t.sleep();
}
}
//父类
class Person{
public String name;
public int age;
public void sleep(){
System.out.println(name+"在休息");
}
}
//子类
class Teacher extends Person{
public String subject; //教授学科
//构造器
public Teacher(){
}
public void teach(){
System.out.println("教书育人!!!");
}
}
//子类
class Student extends Person{
public int num; //学号
//构造器
public Student(){
}
public void study(){
System.out.println("学习!!!");
}
}
2.访问权限修饰符 :
本类 同包类 不同包下的类 不同包下的其他类
private私有的 √
default默认的 √ √
protected受保护的 √ √ √
public公共的 √ √ √ √
注意:
都是成员修饰符,只能修饰成员,不能修饰局部
能够修饰类的 : public | default
Protected修饰的成员在不同包下的子类中,需要通过继承关系使用
最常用的两种权限 : public|private
public class Class001_Modifier {
public String testPublic = "public";
protected String testProtected = "protected";
String testDefault = "default";
private String testPrivate = "private";
public static void main(String[] args) {
new Class001_Modifier().test();
}
public void test(){
//测试本类中使用
System.out.println(testPublic);
System.out.println(testProtected);
System.out.println(testDefault);
System.out.println(testPrivate);
}
public static void testStatic(){
//测试本类中使用
Class001_Modifier cm = new Class001_Modifier();
System.out.println(cm.testPublic);
System.out.println(cm.testProtected);
System.out.println(cm.testDefault);
System.out.println(cm.testPrivate);
}
}
//同包类
class Demo{
public static void main(String[] args) {
//测试本类中使用
Class001_Modifier cm = new Class001_Modifier();
System.out.println(cm.testPublic);
System.out.println(cm.testProtected);
System.out.println(cm.testDefault);
//System.out.println(cm.testPrivate);
}
}
/*
不同包下的子类
*/
public class Son extends Class001_Modifier {
public void test(){
System.out.println(testPublic);
System.out.println(testProtected);
//System.out.println(testDefault);
//System.out.println(testPrivate);
}
public static void main(String[] args) {
//父类对象访问
Class001_Modifier cm = new Class001_Modifier();
//Protected修饰的成员在不同包下的子类中,需要通过继承关系使用
System.out.println(cm.testPublic);
//System.out.println(cm.testProtected);
//子类对象访问
Son son = new Son();
System.out.println(son.testPublic);
System.out.println(son.testProtected);
}
}
3. super 与 this 之间的区别:
this 指代当前new对象
本类构造器的首行调用本类中的其他构造器this(参数列表)
区分局部与成员同名问题
默认就近原则
通过this.调用成员
super 指代父类对象
子类构造器的首行,通过super(参数)调用父类中的指定构造器
如果没有显示通过super(参数)调用,默认调用父类的空构造
区分子父类中同名成员
如果不存在同名问题 : 可以省略super.调用父类成员
如果存在子父类同名成员问题,同名局部问题 :
默认就近原则
有局部找局部
通过this.找子类成员
通过super.找父类成员
注意:
子父类继承关系下 : 创建子类对象的时候,其实会先父类后子类
不能在构造器的首行同时使用this(参数)与super(参数)
this与super都不能使用在静态方法中
public class Class001_Super {
public static void main(String[] args) {
Zi zi = new Zi("");
zi.test();
}
}
class Fu{
String str = "FuStr";
public Fu(){
System.out.println("Fu");
}
public Fu(int i){
System.out.println("Fu");
}
}
class Zi extends Fu{
//String str = "ZiStr";
public Zi(){
super(100);
//super();
System.out.println("Zi");
}
public Zi(String s){
this();
System.out.println("Zi----String");
}
public void test(){
String str = "local";
System.out.println(super.str);
}
}
/*
测试 :
*/
public class Class002_Animal {
public static void main(String[] args) {
Pig pig = new Pig("佩奇","小香猪","粉色");
pig.show();
}
}
//父类
class Animal{
public String type;
public String color;
public Animal(){
}
public Animal(String type,String color){
this.type = type;
this.color=color;
}
public void eat(){
System.out.println("觅食...");
}
}
4.重写 与 重载 之间的区别 :
都是方法的特性
重载的实现条件 :
1.一个类中的多个方法
2.方法名相同
3.参数列表不同|方法签名不同
重写的实现条件:
1.两个类
2.继承|实现
3.方法签名完全相同
重写的需求 :
当子类从父类中继承的功能满意,对功能实现不满意的时候,可以在子类对从父类中继承的功能重新实现
调用使用 :
如果子类中没有重写,调用父类的,父类没有报错
如果子类存在重写方法,调用子类中重写后的方法,对父类的方法进行屏蔽
检测是否为重写方法 :
1.idea行号后面的位置出现o向上箭头
2.在重写方法上添加注解 @Override
不能被重写的方法 :
1.被private修饰的方法不能被重写
能被子类继承,但是无权使用
2.被final修饰的方法不能被重写
3.被static修饰的方法不能被重写
可以被继承不能被重写
如果子类中出现与父类中静态方法同名的方法,要求子类中这个同名的方法也被static修饰
public class Class001_Override {
public static void main(String[] args) {
SiCong siCong = new SiCong();
siCong.words();
siCong.test();
}
}
5. final 最终的
被final修饰的变量为常量
被final修饰的方法不能被重写
被final修饰的类不能被继承-->太监类
public class Class001_Final {
final static Student s = new Student();
public static void main(String[] args) {
//s = new Student();
System.out.println(s.age);
s.age++; //只修改了对象内存空间中的属性值,没有修改s存储对象地址值,所有s还是常量
System.out.println(s.age);
}
}
class Student{
int age = 18;
}
class JianLin{
String name = "王健林";
//名人名言
public static void words(){
System.out.println("先定义小目标,挣它一个亿...");
}
public static void test(){}
}
class SiCong extends JianLin{
String name = "王思聪";
重写方法
public static void words(){
System.out.println("我在不在乎我的朋友有钱没有,反正都没我有钱...");
}
}
//pig
class Pig extends Animal{
public String name;
public Pig(){}
public Pig(String name){
this.name = name;
}
public Pig(String name,String type,String color){
super(type,color);
this.name = name;
}
public void show(){
System.out.println(name+"--->"+type+"--->"+super.color);
}
}
6.Javabean :
一系列实体类的统称
定义规范 :
1.类是公共的
2.至少一个空构造
3.属性私有化
4.提供一对公共的访问方式
public class Class001_Javabean {
}
1252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
