note_doit_day08-优快云博客

本文链接：https://blog.youkuaiyun.com/dq_dsj/article/details/118895076

本文介绍了Java中的匿名对象、类的继承和抽象类的概念及应用。匿名对象不绑定引用变量，只能使用一次，可作为参数和返回值。类的继承允许子类继承父类的属性和行为，实现代码复用。方法重写用于子类扩展或改变父类方法。抽象类包含抽象方法，不允许实例化，子类必须重写所有抽象方法。通过实例展示了这些概念如何在实际编程中使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.匿名对象:
   定义:一个对象不给引用变量赋值直接使用就是匿名对象没有变量名的对象
       1.匿名对象如果不给引用变量赋值只能使用一次
       2.匿名对象可以作为方法的参数和返回值使用

2.类的继承:
   讲师类
属性
工号
姓名
年龄
行为
工作
继承概念
当定义一个类时 ,发现已有类(员工类) 与要定义的类(讲师类)相似,
并且要定义的类属于已有类的一种此时可以将要定义的类定义为已有类子类.
   子类继承父类后自动拥有父类所有可继承的属性和行为

继承的格式:
public class 子类 extends 父类{
}

   方法重写:
当子类继承父类后,自动拥有父类所有公共的属性和行为,可以直接调用;其功能,但是如果子类觉得父类的方法不够强大,可以按照自身的逻辑重新
定义方法,这种叫做方法重写也叫做方法复写方法覆盖
   tip:
       1.可以使用@Override验证是否是方法重写
2.子类方法的访问权限必须大于等于父类方法的访问权限
3.方法重写正常来说方法名必须相同参数列表必须相同
但是返回值类型可以有不同的情况
如果返回值类型是基本类型必须相同
如果返回值类型是引用类型可以相同
也可以不同子类方法的返回值类型是父类方法的返回值类型
的子类
       4:变量的就近访问原则
       局部>子类成员 >父类成员
   EXP:
       员工类:
       public class Employee {
       private String id;
       private String name;
       private int age;

       public void work(){
           System.out.println("工作了");
       }

       public String getId() {
           return id;
       }

       public void setId(String id) {
           this.id = id;
       }

       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;
       }
   }
   教师类:
       public class Teacher extends Employee{
       public void work(){
           System.out.println("讲师讲课");
       }

       public void playGame(){
           System.out.println("讲师玩游戏");
       }
   }
   实例化:
       public class Test {
       public static void main(String[] args) {

Teacher t = new Teacher();

t.work();

t.playGame();

t.setName("柳岩");
t.setAge(38);

           System.out.println(t.getName());
           System.out.println(t.getAge());
           System.out.println(t.getId());
       }
   }

3.this&super:
   1.this调用本类的构造方法
this(实际参数)
tips: this() 需要写在构造方法的第一行写了this() 那么就没有super()了
因为this()调用的其他构造方法而其他构造方法中一定有super()

   2.this.成员变量访问当前对象的成员变量
super.成员变量(非私有) 访问是当前对象中父类空间的成员变量
this.成员方法(实际参数) 访问子类的成员方法
super.成员方法(实际参数) 访问父类的成员方法(非私有)

   fu:
       public class Fu {

String name = "父类成员变量";
int a = 10;

       public void method2(){
           System.out.println("fu");
       }

       public void method3(){
           System.out.println("fufu");
       }
   }
   zi:
       public class Zi extends Fu {
       String name = "子类的成员变量";
       int b = 20;
       public void method(){
           String name = "局部变量";

           System.out.println(name);
           //this和super区分同名的成员变量
           System.out.println(this.name);
           System.out.println(super.name);

           //不同名的成员变量可以直接访问用this或super都可以
   System.out.println(this.a);
   System.out.println(super.a);
   System.out.println(b);

           //方法同名可以使用this和super区分
       this.method2();
       super.method2();

       //方法不同名用谁都可以访问
       this.method3();
       super.method3();
       }
       @Override
       public void method2(){
           System.out.println("zi");
       }
   }
   test:
       public class Test {
       public static void main(String[] args) {
           Zi zi = new Zi();
           zi.method();
       }
   }

4.抽象类:
   抽象方法:没有方法体的方法,可以为抽象方法
抽象类:有抽象方法的类,就必须是抽象类
   tips:
       1.抽象类可以有具体的方法为了给子类使用
2.抽象类可以没有抽象方法为了不让别人创建这个抽象类的对象要创建只能创建子类对象
3.抽象类可以有多个抽象方法子类必须全部重写才可以编译通过创建对象否则子类也必须是一个抽象类才能编译通过
4.抽象类有构造方法为了给子类使用
   抽象类的使用:
1.抽象类不能创建对象
2.定义子类继承抽象类
3.重写父类的所有的抽象方法
4.创建子类对象调用方法
   员工类:
       public abstract class Employee {

private String name;
private int age;

       public Employee(){
           super();
       }

public abstract void eat();

public abstract void work();

       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;
       }
   }
   老师类:
           public class Teacher extends Employee {
           public Teacher(){
               super();
           }

           //子类必须全部重写父类的抽象方法才可以创建对象
           @Override
           public void eat() {

}

           @Override
           public void work() {
               System.out.println("讲师讲课");
           }
       }
       test:
       public class Test {
       public static void main(String[] args) {

           Teacher t = new Teacher();
           t.work();
       }
   }

5.员工案例:
   1.员工类:
       public abstract class Employee {
       private String id;
       private String name;

public Employee() {
}

       public Employee(String id, String name) {
           this.id = id;
           this.name = name;
       }

public abstract void work();

       public String getId() {
           return id;
       }

       public void setId(String id) {
           this.id = id;
       }

       public String getName() {
           return name;
       }

       public void setName(String name) {
           this.name = name;
       }
   }
   2.研发部(继承员工):
       public abstract class Developer extends Employee {
       public Developer(String id ,String name){
           super(id,name);
       }
   }
   3.JavaEE研发:
       public class JavaEE extends Developer {
       public JavaEE(){}
       public JavaEE(String id,String name){
           super(id,name);
       }

       @Override
       public void work() {
           System.out.println("员工号为"+getId()+"的"+getName()+"员工，正在研发淘宝网站");
       }
   }
   4.test:
       public class Test {
       public static void main(String[] args) {
           JavaEE ee = new JavaEE();
           ee.setId("001");
           ee.setName("柳岩");
           ee.work();

           System.out.println("---------------------");
           JavaEE ee2 = new JavaEE("002","唐嫣");
           ee2.work();
       }
   }