Javase进阶笔记-day01

day01面向对象第一章面向对象回顾 1.类与对象

package com.itheima.demo01;


public class Student {
    //私有成员变量
    private String name;
    private int age;

    //添加构造方法:空参数的,满参数的
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //对外提供公共的get/set方法
    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;
    }
}

什么是对象?对象是从类中得到的具体实例！在定义Student类并没有一个具体的人学生现，而创建对象后，就会出现一个具体的学生，比如:

package com.itheima.demo01;


public class Demo01Student {
    public static void main(String[] args) {
        //使用空参数构造方法创建Student对象
        Student s1 = new Student();
        System.out.println("s1:"+s1);//s1:com.itheima.demo01.Student@140e19d
        System.out.println(s1.getName()+"t"+s1.getAge());//null    0 成员变量的默认值
        //使用set方法给成员变量赋值
        s1.setName("小明");
        s1.setAge(18);
        //使用get方法获取成员变量的值
        System.out.println(s1.getName()+"t"+s1.getAge());//小明	18

        //使用满参数构造方法创建Student对象
        Student s2 = new Student("小花",18);
        //使用get方法获取成员变量的值
        System.out.println(s2.getName()+"t"+s2.getAge());//小花	18
        //可以使用set方法修改成员变量的值
        s2.setAge(20);
        System.out.println(s2.getName()+"t"+s2.getAge());//小花	20
    }
}

2.匿名对象

匿名对象:没有名字的对象
创建完对象之后,只有创建对象的语句,不会把对象的地址值赋值给某个变量
格式:
new Student();
特点:
匿名对象只能使用一次
可以直接使用匿名对象调用方法
好处:
使用完毕,会被JVM垃圾回收
节约内存,提高程序的效率

package com.itheima.demo02;

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    
    public void show(){
        System.out.println(name+"t"+age);
    }

    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;
    }
}

package com.itheima.demo02;

import java.util.ArrayList;


public class Demo01Animal {
    public static void main(String[] args) {
        //创建Animal对象
        //我们把new的对象,赋值给了一个引用数据类型的变量,变量名可以重复使用(有名对象)
        Animal a = new Animal("凯特",5);
        //通过对象名.方法名(),调用成员方法
        a.show();
        a.show();
        a.show();
        //匿名对象:只能使用一次
        new Animal("肥波",8).show();//0x888
        //想要再一次使用匿名对象,需要重新new
        new Animal("肥波",8).show();//0x999

        //实际工作中:匿名对象的使用
        //创建一个存储Animal对象的ArrayList集合
        ArrayList list = new ArrayList<>();
        list.add(a);
        //对象只能使用一次,就可以使用匿名对象
        list.add(new Animal("肥波",8));
        list.add(new Animal("熊大",8));
        list.add(new Animal("熊二",8));
    }
}

3.类图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VtqhN2Qv-1657647275519)(img/1620831535518.png)]

二.继承 1.继承的概念

子类继承父类,子类就会自动拥有父的成员变量和成员方法(重点)

2.继承的定义格式和使用格式(重点)

package com.itheima.demo03extends;


public class Person {
    String name;
    int age;

    public void show(){
        System.out.println(name+"t"+age);
    }
}

package com.itheima.demo03extends;


public class Student extends Person{
    //在子类中也可以定义特有的成员
    //学号
    String number;
}

package com.itheima.demo03extends;


public class Teacher extends Person{
    //定义特有的成员
    //工资
    double salary;
}

package com.itheima.demo03extends;


public class Demo01 {
    public static void main(String[] args) {
        //创建子类Student对象
        Student s1 = new Student();
        //子类使用继承自父类的成员变量
        s1.name = "小明";
        s1.age = 18;
        //使用子类特有的成员
        s1.number = "hm390-01";
        //使用子类继承自父类的成员方法
        s1.show();
        System.out.println("学号:"+s1.number);

        //创建子类Teacher对象
        Teacher t = new Teacher();
        //子类使用继承自父类的成员变量
        t.name = "老王";
        t.age = 30;
        //使用子类特有的成员
        t.salary = 50;
        //使用子类继承自父类的成员方法
        t.show();
        System.out.println("工资:"+t.salary);
    }
}

3.继承练习

需求:使用继承完成以下案例

我们在商场中能见到各种工作人员，每种工作人员在系统中就是使用实体类的方式定义的。
请模拟商场的信息系统使用继承定义以下实体类。
工作人员(Worker): 属性：姓名(name),工号(id)
方法 : 工作(work)

售货员(Sales): 属性：姓名(name),工号(id)
方法 : 工作(work)

收银员(Cashier) 属性：姓名(name),工号(id)
方法 : 工作(work)

package com.itheima.demo04Test;


public class Worker {
    //姓名
    String name;
    //工号
    String id;

    //工作的方法
    public void work(){
        System.out.println(name+"正在工作");
    }
}

package com.itheima.demo04Test;


public class Sales extends Worker{
}

package com.itheima.demo04Test;


public class Cashier extends Worker{
}

package com.itheima.demo04Test;

public class Demo01 {
    public static void main(String[] args) {
        //创建子类Sales对象
        Sales s = new Sales();
        //子类调用继承父类的成员变量和成员方法
        s.name="尼格买提";
        s.id = "hm001";
        s.work();

        //创建子类Cashier对象
        Cashier c = new Cashier();
        //子类调用继承父类的成员变量和成员方法
        c.name="马尔扎哈";
        c.id="hm002";
        c.work();
    }
}

4.继承的注意事项

1.构造方法不能继承,每个类需要写自己的构造方法
通常情况下：子类要参考父类，来定义相同形式的构造方法。

2.父类的私有成员子类虽然可以继承,但是私有修饰的成员只能在本类中使用,
所以无法在子类中直接使用

package com.itheima.demo05extends;

public class Fu {
    private String name;
    private int age;

    public Fu() {
    }

    public Fu(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

package com.itheima.demo05extends;


public class Zi extends Fu {
}

package com.itheima.demo05extends;

public class Demo01 {
    public static void main(String[] args) {
        //使用Zi类的默认空参数构造方法创建对象
        Zi zi = new Zi();

        //使用Zi类的默认满参数构造方法创建对象
        //没有==>报错(构造方法不能继承:创建本类对象使用)
        //Zi zi2 = new Zi("小王",18);

        //使用功能zi类继承自父类的私有成员:不能直接使用
        //'name' has private access in 'com.itheima.demo05extends.Fu'
        //System.out.println(zi.name);
        //通过子类继承父类的公共的get/set方法,访问私有的成员变量
        zi.setName("小王");
        zi.setAge(18);
        System.out.println(zi.getName()+"t"+zi.getAge());
    }
}

5.继承后的特点—成员变量

package com.itheima.demo06variable;


public class Demo01 {
    public static void main(String[] args) {
        //创建Zi类对象
        Zi zi = new Zi();
        System.out.println(zi.a);//100 子类有使用子类自己的
        System.out.println(zi.b);//20  子类没有使用继承自父类的
        //System.out.println(zi.c);//Cannot resolve symbol 'c'  子类和父类都没有,编译报错
    }
}

package com.itheima.demo06variable;

public class Fu {
    int a = 10;
    int b = 20;
}

package com.itheima.demo06variable;

public class Zi extends Fu {
    int a = 100;
}

6.继承后的特点—成员方法

package com.itheima.demo07method;


public class Demo01 {
    public static void main(String[] args) {
        //创建Zi类对象
        Zi zi  = new Zi();
        zi.show01();//Zi类的show01方法!
        zi.show02();//Fu类的show02方法!
        //zi.show03();//Cannot resolve method 'show03()' 都没有报错
    }
}

package com.itheima.demo07method;

public class Fu {
    public void show01(){
        System.out.println("Fu类的show01方法!");
    }

    public void show02(){
        System.out.println("Fu类的show02方法!");
    }
}

package com.itheima.demo07method;

public class Zi extends Fu {
    public void show01(){
        System.out.println("Zi类的show01方法!");
    }
}

7.继承后的特点—构造器(构造方法)

在每个子类的构造方法第一行,都有一个默认的super();不写默认也有
作用:调用父类的空参数构造方法,创建父类对象
为什么?
因为子类继承父类,想使用继承自父类的成员,必须先创建父类对象,把父类加载到内存中
子类才可以使用

package com.itheima.demo08Constructor;

public class Fu {
    int a = 10;

    public Fu() {
        System.out.println("Fu类的空参数构造方法!"+a);
    }
}

package com.itheima.demo08Constructor;

public class Zi extends Fu{
    
    public Zi() {
        super();
        System.out.println("Zi类的构造方法!"+a);
    }
}

package com.itheima.demo08Constructor;

public class Demo01 {
    public static void main(String[] args) {
        //创建Zi类对象
        Zi zi = new Zi();
    }
}

8.子父类的内存图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xYkPxqXv-1657647275519)(img/1647228835009.png)]

9.使用this关键字和super关键字访问成员(重点)

package com.itheima.demo09thisAndsuper;

public class Fu {
    int a = 10;

    public void show(){
        System.out.println("Fu类的show方法!");
    }
}

package com.itheima.demo09thisAndsuper;


public class Zi extends Fu{
    int a = 20;

    public void show(){
        System.out.println("Zi类的show方法!");
    }

    public void method(){
        int a = 30;
        System.out.println("变量的就近访问原则:"+a);//30
        System.out.println("this.a:"+this.a);//this.a:20
        System.out.println("super.a:"+super.a);//super.a:10
        this.show();//Zi类的show方法!
        show();//Zi类的show方法!
        super.show();//Fu类的show方法!
    }
}

package com.itheima.demo09thisAndsuper;

public class Demo01 {
    public static void main(String[] args) {
        //创建Zi类对象
        Zi zi = new Zi();
        zi.method();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ulVcb6jn-1657647275520)(img/1647229487010.png)]

10.this关键字:可以调用本类其他构造方法(重点)

package com.itheima.demo10this;


public class Animal {
    private String name;
    private int age;

    public Animal() {
        //在空参数构造方法中调用满参数构造方法
        this("吴彦祖",30);
        System.out.println("Animal的空参数构造方法!");
    }

    public Animal(String name, int age) {
        System.out.println("Animal的满参数构造方法!");
        this.name = name;
        this.age = age;
    }

    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;
    }
}

package com.itheima.demo10this;

public class Demo01This {
    public static void main(String[] args) {
        //使用Animal的空参数构造方法创建对象
        Animal a = new Animal();
        System.out.println(a.getName()+"t"+a.getAge());

        
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pmhc6qjs-1657647275520)(img/1647230341455.png)]

package com.itheima.demo11this;


public class Animal {
    private String name;
    private int age;

    public Animal() {
        System.out.println("Animal的空参数构造方法!");
    }

    public Animal(String name, int age) {
        //调用本类的空参数构造方法
        this();
        System.out.println("Animal的满参数构造方法!");
        this.name = name;
        this.age = age;
    }

    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;
    }
}

package com.itheima.demo11this;

public class Demo01This {
    public static void main(String[] args) {
        //使用Animal的满参数构造方法创建对象
        Animal a = new Animal("胡歌",30);
        System.out.println(a.getName()+"t"+a.getAge());

        
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mwk1zTnL-1657647275520)(img/1647230727262.png)]

11.super关键字:调用父类的构造方法(重点)

package com.itheima.demo12super;

public class Animal {
    private String name;
    private int age;

    public Animal() {
        System.out.println("Animal类的空参数构造方法!");
    }

    public Animal(String name, int age) {
        System.out.println("Animal类的满参数构造方法!");
        this.name = name;
        this.age = age;
    }

    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;
    }
}

package com.itheima.demo12super;


public class Cat extends Animal{
    public Cat() {
        super();//调用父类空参数构造方法
        System.out.println("Cat类的空参数构造方法!");
    }

    public Cat(String name, int age) {
        super(name, age);//调用父类带参数构造方法
        System.out.println("Cat类的满参数构造方法!");
    }
}

package com.itheima.demo12super;

public class Demo01 {
    public static void main(String[] args) {
        //使用Cat类的空参数构造方法创建对象
        Cat c1 = new Cat();
        System.out.println(c1.getName()+"t"+c1.getAge());

        

        //使用Cat类的满参数构造方法创建对象
        Cat c2 = new Cat("大黄",5);
        System.out.println(c2.getName()+"t"+c2.getAge());

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r9Bv6qBA-1657647275520)(img/1647240757706.png)]

12.访问修饰符

package com.itheima.demo13access;


public class Person {
    private int a = 10;
    int b = 20;
    protected int c = 30;
    public int d = 40;

    public void show(){
        
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

package com.itheima.demo13access;


public class Demo01Access {
    public static void main(String[] args) {
        //创建Person对象
        Person p = new Person();
        //System.out.println(p.a);//'a' has private access in 'com.itheima.demo13access.Person'
        System.out.println(p.b);
        System.out.println(p.c);
        System.out.println(p.d);
    }
}

package com.itheima.demo14access;

import com.itheima.demo13access.Person;



public class Student extends Person {
    public void method(){
        //System.out.println(a);//'a' has private access in 'com.itheima.demo13access.Person'
        //System.out.println(b);//'b' is not public in 'com.itheima.demo13access.Person'. Cannot be accessed from outside package
        System.out.println(c);
        System.out.println(d);
    }
}

package com.itheima.demo14access;


public class Demo02Access {
    public static void main(String[] args) {
        Student s = new Student();
        //System.out.println(s.a);//'a' has private access in 'com.itheima.demo13access.Person'
        //System.out.println(s.b);//'b' is not public in 'com.itheima.demo13access.Person'. Cannot be accessed from outside package
        //System.out.println(s.c);//'c' has protected access in 'com.itheima.demo13access.Person'
        System.out.println(s.d);
    }
}

13.Java中继承的注意事项

Java中类只支持单继承，不支持多继承(一个人只能有一个亲爹)
Java中类支持多层继承,在java中有一个类叫Object,所有的类都直接或者间接的继承了Object类(祖宗类)
Java中支持一个父类可以有多个子类(一个人可以有多个孩子)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-abdZLK2T-1657647275520)(img/1647242309554.png)]

14.方法重写(Override)(重点)

方法重写:
在子类中出现了和父类一模一样的方法
一模一样:
方法的修饰符>=父类方法的修饰符
方法的返回值类型,方法名和参数列表必须和父类一模一样

在子类中方法重写的目的:是为了让子类的方法更加强大

package com.itheima.demo14Override;


public class Person {
    private String name;
    private int age;

    public void show(){
        System.out.println(name+"t"+age);
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

package com.itheima.demo14Override;

public class Student extends Person {
    //在子类中也可以定义特有的成员
    //学号
    private String number;

    
    public void show(){
        super.show();//调用父类的show方法,可以沿袭父类的功能
        System.out.println(number);
    }

    public Student() {
    }

    public Student(String name, int age, String number) {
        super(name, age);
        this.number = number;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }
}

package com.itheima.demo14Override;


public class Teacher extends Person {
    //定义特有的成员
    //工资
    private double salary;

    
    @Override
    public void show() {
        super.show();
        System.out.println(salary);
    }

    //Build completed successfully in 1 s 962 ms (2 minutes ago)
    //@Override
    public void show02(){

    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

package com.itheima.demo14Override;

public class Demo01Override {
    public static void main(String[] args) {
        //创建子类Student对象
        Student s = new Student("小明",18,"hm001");
        //调用子类重写的show方法
        s.show();

        //创建子类Teacher对象
        Teacher t = new Teacher();
        t.setName("老王");
        t.setAge(30);
        t.setSalary(50);
        //调用子类重写的show方法
        t.show();
    }
}

15.方法重写的注意事项(了解)

1.方法重写是发生在子父类之间的关系
2.私有方法不能被重写:私有方法只能在本类中使用,不能重写
3.构造方法也不能重写:构造方法是创建本类对象使用的,不能继承,也不能重写
4.子类方法访问权限不能比父类更低(public >protected >默认(不写)> private)
5.子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样。

package com.itheima.demo15Override;

public class Fu {
    private void show(){
        System.out.println("Fu类的show方法!");
    }

    protected void show2(){
        System.out.println("Fu类的show2方法!");
    }

    public void show3(){
        System.out.println("Fu类的show3方法!");
    }

    public void show4(){
        System.out.println("Fu类的show4方法!");
    }
}

package com.itheima.demo15Override;


public class Zi extends Fu{
    //私有方法不能重写 Method does not override method from its superclass
    

    //子类方法访问权限>=父类权限(public >protected >默认 > private)
    @Override
    public void show2() {
        super.show2();
    }

    

    
}

16.方法重写练习

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E5B4rUOJ-1657647275520)(img/1647246510843.png)]

package com.itheima.demo16Test;


public class Worker {
    private String name;
    private String id;

    //定义工作的work方法
    public void work(){
        System.out.println(name+"正在工作");
    }

    public Worker() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

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

package com.itheima.demo16Test;


public class Sales extends Worker{
    public Sales() {
    }

    public Sales(String name, String id) {
        super(name, id);
    }

    //重写父类的work方法
    @Override
    public void work() {
        super.work();//调用父类的方法
        System.out.println("我是一名售货员");
    }
}

package com.itheima.demo16Test;

public class Cashier extends Worker{
    public Cashier() {
    }

    public Cashier(String name, String id) {
        super(name, id);
    }

    //重写父类的work方法
    @Override
    public void work() {
        super.work();//调用父类的成员方法
        System.out.println("我是一名收银员");
    }
}

package com.itheima.demo16Test;

public class Demo16Test {
    public static void main(String[] args) {
        //创建Sales对象
        Sales s = new Sales("尼格买提","hm007");
        s.work();

        //创建Cashier对象
        Cashier c = new Cashier();
        c.setName("马尔扎哈");
        c.work();
    }
}

17.方法重载与重写的区别

方法重写(Override):在子类中出现了和父类一模一样(方法名,参数列表,返回值类型,修饰符>=父类)的方法,叫子类重写了父类的方法

方法重载(Overload):在同一个类中,出现了方法名相同,但是参数列表不同(个数,类型,顺序)的方法,多个方法构成重载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-urWL9tSz-1657647275520)(img/1647246333576.png)]

三.抽象类 1.抽象类和抽象方法的由来(了解)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-22ZFGore-1657647275521)(img/1647248074496.png)]

注意:抽象类一般都是父类,是根据子类共性抽取形成

2.抽象类和抽象方法的使用(重点)

抽象类和抽象方法存在的意义:

限定子类必须完成某些动作
规定所有的子类必须的工作,可以在父类定义一个抽象的工作方法,让所有子类必须重写抽象工作方法(必须工作)

package com.itheima.demo17abstract;


public abstract class Employee {
    private String name;
    private int age;

    //定义抽象的工作方法
    public abstract void work();

    public Employee() {
    }

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

    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;
    }
}

package com.itheima.demo17abstract;


public class Teacher extends Employee{
    @Override
    public void work() {
        System.out.println("讲师正在给大家讲解java!");
    }
}

package com.itheima.demo17abstract;


public class BanZhuRen extends Employee{
    @Override
    public void work() {
        System.out.println("班主任正在管理班级!");
    }
}

package com.itheima.demo17abstract;


public class JiuYeZhiDao extends Employee{
    public JiuYeZhiDao() {
    }

    public JiuYeZhiDao(String name, int age) {
        super(name, age);
    }

    @Override
    public void work() {
        System.out.println("就业指导"+getName()+"正在辅导大家写简历!");
    }
}

package com.itheima.demo17abstract;

public class Demo01 {
    public static void main(String[] args) {
        
        //'Employee' is abstract; cannot be instantiated
        //Employee ee = new Employee();

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

        BanZhuRen bzr = new BanZhuRen();
        bzr.work();

        JiuYeZhiDao jyzd = new JiuYeZhiDao("小张",25);
        jyzd.work();
    }
}

3.抽象类的特征

抽象类的特征总结起来可以说是有得有失

有得：抽象类得到了拥有抽象方法的能力。

有失：抽象类失去了创建对象的能力。

其他成员（构造器(构造方法)，实例(成员)方法，静态方法等）抽象类都是具备的。

4.注意事项

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
```
//不包含抽象的方法的抽象类,仅仅是不想让别人创建对象使用
public abstract class Person {
}
```
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

5.抽象类练习练习1：抽象类、抽象方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U6PwsYIr-1657647275521)(img/1647249807296.png)]

父类抽象类

package com.itheima.demo18Test;

public abstract class Worker {
    private String name;
    private String id;

    //定义抽象的工作方法
    public abstract void work();

    public Worker() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

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

子类重写抽象方法

package com.itheima.demo18Test;


public class Cashier extends Worker{
    public Cashier() {
    }

    public Cashier(String name, String id) {
        super(name, id);
    }

    @Override
    public void work() {
        System.out.println(getName()+"正在工作,我是一名售货员");
    }
}

package com.itheima.demo18Test;

public class Sales extends Worker{
    public Sales() {
    }

    public Sales(String name, String id) {
        super(name, id);
    }

    @Override
    public void work() {
        System.out.println(getName()+"正在工作,我是一名收银员");
    }
}

测试类

package com.itheima.demo18Test;

public class Demo18Test {
    public static void main(String[] args) {
        Cashier c = new Cashier("尼格买提","hm001");
        c.work();//调用子类重写后的方法

        Sales s = new Sales("马尔扎哈","hm002");
        s.work();//调用子类重写后的方法
    }
}

练习2：抽象类、抽象方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-koDF4YXW-1657647275521)(img/1647249825900.png)]

package com.itheima.demo19Test;

public abstract class Animal {
    private String name;
    private int age;
    private double weight;

    //定义抽象的eat方法
    public abstract void eat();

    public Animal() {
    }

    public Animal(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    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 double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
}

子类

package com.itheima.demo19Test;

public class Ostrich extends Animal{
    public Ostrich() {
    }

    public Ostrich(String name, int age, double weight) {
        super(name, age, weight);
    }

    @Override
    public void eat() {
        System.out.println(getName()+"爱吃杂食");
    }

    //特有的run方法
    public void run(){
        System.out.println(getName()+"是世界上跑的最快的鸟类");
    }
}

package com.itheima.demo19Test;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age, double weight) {
        super(name, age, weight);
    }

    @Override
    public void eat() {
        System.out.println(getName()+"爱吃骨头");
    }

    //定义子类特有的看家方法
    public void lookHome(){
        System.out.println(getName()+"能看家");
    }
}

测试

package com.itheima.demo19Test;

public class Demo19Test {
    public static void main(String[] args) {
        Ostrich o = new Ostrich();
        o.setName("驼驼");
        o.eat();
        o.run();

        Dog d = new Dog("田田",5,30);
        d.eat();
        d.lookHome();
    }
}

第四章 final关键字 1.修饰类

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

2.修饰方法

3.修饰变量局部变量

成员变量

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

4.练习

5.总结

final关键字可以修饰哪些地方？
可以修饰类、方法、变量

final 修饰的特点
修饰类：表明该类是最终类，不能被继承
修饰方法：表明该方法是最终方法，不能被重写
修饰变量：表明该变量是常量，不能再次被赋值

Javase进阶笔记-day01

Java相关栏目本月热门文章