构造方法对象的创建步骤static关键字

最新推荐文章于 2023-11-26 16:47:50 发布

大官人的西门庆

最新推荐文章于 2023-11-26 16:47:50 发布

阅读量607

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_56612475/article/details/116031648

版权

构造方法/对象的创建步骤/static关键字/继承方inal法的重写/Final

构造方法概述和格式

A：构造方法的概述和格式

创建对象，给对象中的成员进行初始化

B:构造方法格式特点

a:方法名与类名一样

b:没有返回值类型，连void都没有

c:没有具体的返回值

构造方法的重载及注意事项

A：案例

构造方法的重载

B：构造方法注意事项

a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。

b：如果我们给出了有参数的构造方法，系统将不再提供默认的无参构造方法。

注意：这时候我们还想要使用无参的构造方法，就必须自己给出。建议永远自己给出无参的构造方法

C：给成员赋值的两种方式

a:setxxx（）方法

b:构造方法

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

    //构造方法：他的方法名和类名相同，没有返回值类型，连void也没有。
    //我自己定义类，默认存在一个空参的构造方法。

    //3.一旦你在类中，自己手动定义了有参构造，那么默认无参构造，就不存在了。如果你还想要用空参构造创建对象，建议你把空参构造手动写出来。

    //构造方法也可以重载。
    public Student() {
        System.out.println("空参构造方法调用了");
    }


    public Student(String name) {
        System.out.println("一个参数的构造方法调用了");
        this.name = name;
        this.age = 200;
    }

    public Student(String name, int age) {
        System.out.println("两个参数的构造方法调用了");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    
    
    
public class MyTest2 {
    public static void main(String[] args) {
        //借助空参构造完成类的实例化
        Student student = new Student();
        student.setName("王老虎");
        student.setAge(20);
        System.out.println(student);
        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println("====================================");

        //借助有参构造完成类的实例化
        Student student1 = new Student("abc");
        System.out.println(student1);
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        //采用有参构造，创建对象时，给该对象的实例变量赋值，比较方便。
        Student student2 = new Student("hehe", 100);
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2);

    }
}

一个人类的代码及其测试

A：案例

完善我们的学生类

B : 给成员赋值

a:setxxx()方法

b:构造方法

C：输出成员变量值的方法
a：通过getxxx()分别获取然后拼接

b：通过show()方法搞定

public class Person {
    String name;
    //private 私有的 是一个权限修饰符，可以修饰成员变量和成员方法，被修饰的成员，只能在本类中范围，外界无法直接访问
    //如果外界还想要访问age这个变量，我们可以提供公共的方法，让外界通过调用方法来设置获取私有成员变量的值。
    private int age;


    public void setAge(int nianling) {
        if (nianling > 0 && nianling <= 100) {
            age = nianling;
        }
    }

    public int getAge() {
        return age;
    }

    public void eat() {
        System.out.println("吃饭");
    }
}




public class MyTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "张曼玉";
        //我们之前采用 对象名.成员变量明=值 这种方式给成员变量设置值，会把一些我们认为不合理的数据设置进去，那么我们认为这样不好。
        //我们需要对设置的数据进行一些判断，认为合理后才可以设置。
        //我们可以屏蔽掉 对象名.成员变量明=值 这种方式，那么怎么来屏蔽这种方式，我们可以使用private 关键字来屏蔽。
        //person.age = 2000; 报错age 访问不到，因为age被private修饰了。外界无法直接范围
        person.setAge(200);
        int age = person.getAge();

        System.out.println("姓名：" + person.name);
        System.out.println(age);
        //System.out.println("年龄：" + person.age);
    }
}

一个手机类的代码及测试

创建一个对象

A：画图演示

画图说明一个对象创建过程做了哪些事情？

Student s=new Student();

在这里插入图片描述

步骤：

1: 加载Student.class文件进内

2：在栈内存为s开辟空间

3: 在栈内存为学生对象开辟空间

4: 对学生对象的成员变量进行默认初始化

5：对学生对象的成员变量进行显示初始化

6：通过构造方法为学生对象的成员赋值

7：学生对象初始化完毕，把对象地址赋值给s变量

长方形案例

A：案例

需求：

定义一个长方形类，定义周长和面积和方法，然后定义一个Test类，进行测试。

public class Rectangle {
    //定义成员属性
    private double width;
    private double height;

    public Rectangle() {
    }

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    //定义获取周长的方法
    public double getPerimeter() {
        return (this.width + this.height) * 2;

    }

    //定义获取面积的方法
    public double getArea() {
        return width * height;
    }

}



public class MyTest {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(20);
        rectangle.setHeight(10);
        double perimeter = rectangle.getPerimeter();
        double area = rectangle.getArea();
        System.out.println(perimeter);
        System.out.println(area);

        System.out.println("=============================");
        Rectangle rectangle1 = new Rectangle(20, 50);
        System.out.println(rectangle1.getPerimeter());
        double area1 = rectangle1.getArea();
        System.out.println(area1);
    }
}

员工类案例练习

A:案例

需求：定义一个员工的类，自己分析几个成员，然后给出成员变量，构造方法，getxxx()和setxxx()以及一个所有成员信息的方法。并测试。

static关键字的引入

A案例演示

通过一个案例引入static关键字。

人类：Person.每个人都有国籍，中国。

public class Person {
    String name;
    //static 静态的，可以修饰成员变量，修饰变量，此变量为一个共享变量，被该类所有的对象所共享，
    //被static 所修饰的成员是随着类的加载而加载，是优先于对象存在。
    // 也可以修饰成员方法
    static String citizenship = "中国";
}




public class MyTest {
    public static void main(String[] args) {

        Person p1 = new Person();
        p1.name = "张三";
        p1.citizenship = "美国";
        Person p2 = new Person();
        p2.name = "李四";
        p2.citizenship = "英国";
        Person p3 = new Person();
        p3.name = "王五";
        p3.citizenship = "加拿大";
        //静态成员，属于类，我们建议通过类名直接调用，不需要使用对象调用，当然你使用对象调用可以，但是不推荐。
        //静态成员，属于类，所以静态变量，也称之为类变量
        Person.citizenship = "韩国";
        System.out.println(p1.name);
        System.out.println(p1.citizenship);
        System.out.println("================================");
        System.out.println(p2.name);
        System.out.println(p2.citizenship);
        System.out.println("================================");
        System.out.println(p3.name);
        System.out.println(p3.citizenship);
    }
}

static的内存图

A:画图演示：带有static的内存图

在这里插入图片描述

static关键字的特点

A：static关键字的特点

a:随着类的加载而加载

b:优于对象的存在

c:被类的所有对象所共享

举例：咱们班级的学生应该共用一个班级编号

其实这个特点也是在告诉我们什么什么时候使用静态？

如果某个成员时被所有对象所共享的，那么它就应该被定义静态。

举例：饮水机（用静态修饰）

水杯：(不能静态修饰)

d:通过类名调用

其实它本身也可以对象名调用。

推荐使用类名调用

静态修饰的内容一般我们称其为：与类相关的，类成员

B：案例

static关键字的特点

public class Dog {
    public double num = 20;
    public static int a = 120;

    //非静态方法，既可以访问非静态的，也可以访问静态的。
    public void show() {
        System.out.println(num);
        System.out.println(a);
    }

    public void show2() {
        System.out.println(num);
        System.out.println(a);
        this.show();
        this.test();
        Dog.test();
    }

    //静态方法中，只能访问到静态成员，访问不到非静态成员。
    //被静态所修饰的成员，是随着类的加载而加载，是优先于对象而存在。
    //先有的访问不到后来才有的。
    //静态的只能访问静态的。
    public static void test() {
        // System.out.println(num);
        System.out.println(a);
    }

    //静态的只能访问静态的。
    public static void test2() {
        //静态方法里面不能存在this关键字，this代表一个对象，是后来才有的，静态方法里面访问不到
        //this.show();
        System.out.println(a);
    }
}

静态变量和成员变量的区别

A：所属不同

静态变量属于类，所以也被称为类变量

成员变量属于对象，所以也被实例变量（对象变量）

B：内存中位置不同

静态变量存储于方法区的静态区，JDK1.7之后存储在堆内存中

成员变量存储在堆内存

C：内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

D：调用不同

静态变量随着类名调用，也可以通过对象调用，推荐使用类名调用

成员变量只能通过对象名调用

###如何通过JDK 提供的帮助文档

A：找到文档，打开文档

B: 点击显示，找到索引，出现输入框

C:你应该知道找到谁?举例：Scanner

D：看到这个类的结构（需不需要导包）

java.lang 包下的内容不需要我们手动导入

其他包下的内容不需要我们手动导入

类 API文档

成员变量字段摘要

构造方法构造方法摘要

成员方法方法摘要

E：看这个类的说明

F：看开始版本

G：看构造方法

H: 看成员方法

看左边：

看是否是static的，如果是我们就不需要创建对象，直接使用类名调用该方法就可以了，看返回值，返回值是什么，我们就使用什么接收

看右边：

看参数列表：参数的个数，参数的类型：要什么参数我使用的时候，就传递什么参数

I：然后使用

学习Math类的随机数功能

打开JDK提供的帮助文档学习

A：math类概述

类包含用于执行基本数学运算方法

B: math类的特点

由于math类在Java.lang 包下，所以不需要导包。

没有构造方法，因为它的成员全部是静态的。

C：获取随机数的方法

public static double random():返回带正号的double值，该值大于等于0.0且小于1.0.

D：我要获取一个1到100的随机数，怎么办？

int number = （int）（Math.random()*100+1）

猜数字小游戏案例

A：案例：需求：猜数字小游戏（数据在1到100之间）

public class MyTest {
    public static void main(String[] args) {
        //Math:关于数学方面的工具类

      /*  for (int i = 0; i < 100; i++) {
            //生成随机小数 范围 0---1之间的小数
            double v = Math.random();
            System.out.println(v);
        }*/

        //我想要 1---100之间随机整数 包含1 和 100


        for (int i = 0; i < 1000; i++) {
            int v = (int) (Math.random() * 100 + 1);
            if (v == 1) {
                System.out.println(v);
            }

        }
    }
}





public class GuessNumber {
    public static void main(String[] args) {
        int num = (int) (Math.random() * 100 + 1);
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.println("请输入一个整数 1---100");
            int userNum = sc.nextInt();
            if (userNum > num) {
                System.out.println("猜大了");
            } else if (userNum < num) {
                System.out.println("猜小了");
            } else {
                System.out.println("恭喜你猜对了");
                break;
            }
        }
    }
}

代码块的概述和分类

A：代码块概述

在Java中，使用{}括起来的代码被称为代码块。

B：代码块分类

根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块（多线程）。

C：常见代码块的应用

a:局部代码块

在方法中出现，限定变量生命周期，及早释放，提高内存利用率

b:构造代码块

在类方法外出现；多个构造方法中相同的代码存放在一起，每次调用构造都执行，并且在构造方法前执行

C：静态代码块

在类中方法外执行，加了static修饰

在类中方法外出现，并加上static修饰，用于给类初始化，在加载的时候就执行，并且只执行一次。

看程序写结果

class Student {
		static {
			System.out.println("Student 静态代码块");  //3
		}
		
		{
			System.out.println("Student 构造代码块");//46
		}
		
		public Student() {
			System.out.println("Student 构造方法");//57
		}
	}

	class StudentDemo {
		static {
			System.out.println("StudentDemo的静态代码块"); //1
		}
		
		public static void main(String[] args) {
			System.out.println("我是main方法"); //2
		
			Student s1 = new Student();
			Student s2 = new Student();
		}
	}

继承的引入和概述

A：继承概述

多个类中存在相同属性和行为时，将这些内容抽取在一个单独的一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

B : 继承格式

通过extends关键字可以实现类与类的继承

class子类名extends父类名{}

单独的这个类称为父类，基类或者超类，者多个类可以被称为子类或者派生类。

继承案例以及它的好处和弊处

A：需求：

学生类和老师类

定义两个功能{吃饭，睡觉}

B：案例

使用继承前

使用继承后

public class MyTest {
    public static void main(String[] args) {
        //面向对象的三大特征：封装，继承，多态
        //封装：类，就是体现的封装的思想，封装了属性和功能。

        //继承：生活中的继承,儿子可以继承老子的财产。
        //Java中的继承：子类可以继承父类的成员。
        //我们使用关键字 extends 来让类和类之间产生继承关系。

        //继承的好处：
        //1.可以继承父类的成员，提高代码的复用性和维护性。
        //2.继承的弊端：让类和类产生了关系，增加了耦合性，软件的设计原则，遵循高内聚，低耦合。
        //3.继承，其实就是把多个子类共性的部分，向上抽取到父类中。
        /*
        *   开发的原则：高内聚，低耦合。
	       耦合：类与类的关系
	       内聚：就是自己完成某件事情的能力
        *
        * */


        Zi zi = new Zi();
        zi.name = "王五";
        zi.age = 12;
        zi.sleep();
        zi.eat();
        zi.playGame();
        System.out.println(zi.name);
        System.out.println(zi.age);

        System.out.println("=======================================");
        Zi2 zi2 = new Zi2();
        zi2.name = "李四";
        zi2.age = 25;
        zi2.sleep();
        zi2.eat();
        zi2.sing();
        System.out.println(zi2.name);
        System.out.println(zi2.age);


    }
}

class Fu {
    String name;
    int age;

    public void eat() {
        System.out.println("吃饭饭");
    }

    public void sleep() {
        System.out.println("睡觉觉");
    }


}

class Zi extends Fu {


    public void playGame() {
        System.out.println("玩游戏");
    }
}

class Zi2 extends Fu {


    public void sing() {
        System.out.println("唱歌");
    }

}

C : 继承的好处

a:提高了代码的复用性

b：提高了代码的维护性

c:让类与类之间产生了关系，时多态的前提

E：继承的弊端

类的耦合性增强了。

开发的原则：高类聚，低耦合。

耦合:类与类的关系

内聚：就是自己完成某件事情的能力

java中类的继承特点

A：Java中类的继承特点

a:Java只支持单继承，不支持多继承。

有些语言时支持多继承，格式：extend 类1，类2，，，

b:java支持多层继承

B:案例

Java类的继承特点

public class MyTest3 extends Object {
    public static void main(String[] args) {
        /*
         *  Java中继承的特点：
         *  1.Java中只支持单继承，一个子类只能有一个直接父类，但是支持多层继承。
         *  2.子类只能继承父类非私有的成员。
         *  3.构造方法不参与继承，构造方法的作用就是，你在初始化子类时，先要初始化父类。
         *
         *  Object类：是所有类的顶层父类，所有类都是直接或间接继承自他。
         *
         *
         * */

        Son son = new Son();
        System.out.println(son.num);
        System.out.println(son.a);

    }
}

class GrandFather extends Object {
    int num = 200;
    private int aaa = 20;
}

class Father extends GrandFather {
    int a = 30;

}

继承的注意事项和什么时候使用继承

A：继承的注意事项

a:子类只能继承父类所有非私有的成员{成员方法和成员变量}

b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法。

c:不要为了部分功能去继承

B:什么时候使用继承

继承其实体现的是一种关系：“is a”.

采用假设法。

如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承

继承中成员变量的关系

A：子类中的成员变量和父类中的成员变量名称不一样

B: 子类中的成员变量和父类中的成员变量名称一样

在子类访问一个变量的查找规则{就近原则}

a：在子类的方法局部范围中寻找，有就使用

b:在子类的成员范围找，有救使用

c:在父类的成员范围找，悠久使用

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show(5);
        zi.test(800);
    }
}

class Fu {
    int num = 10;

}

class Zi extends Fu {
    int a = 20;
    int num = 500;

    //变量的访问原则,就近原则：先在局部范围找，找到就使用，没找到，去本类的成员范围找，找到就使用，没找到去父类成员范围找，找到就使用。
    public void show(int c) {
        System.out.println(c);
        System.out.println(a);
        System.out.println(num);
    }

    //
    public void test(int num) {
        System.out.println(num); //800
        System.out.println(this.num); //500
        System.out.println(super.num); //10
    }
}

this和super的区别和应用

A：通过问题引出super

子类局部范围访问父类成员变量

B: this和super的区别

this 代表的是本类对象的引用

super 代表的是父类存储空间的标识

C：this和super使用

a：调用成员变量

this.成员变量调用本类的成员变量

super.成员变量调用父类的成员变量

b:调用构造方法

this(…) 调用本类的构造方法

super(…) 调用父类的构造方法

c:调用成员方法

this.成员方法调用本类的成员方法

super.成员方法调用父类的成员方法

继承中构造方法的关系

A：案例

子类中的所有构造方法默认都会访问父类中参数的构造方法

B: 为什么？

因为子类会继承父类中的数据，可能还会使用父类的数据

所以，子类在初始化之前，一定要先完成父类数据的初始化

原因：

每一个构造方法的第一条语句默认都是：super()

public class MyTest {
    public static void main(String[] args) {
        //Father father = new Father();
        //当我们创建子类对象时，会先去调用父类的构造方法？为什么？
        //我们在创建子类对象时，子类要继承父类的成员，甚至还要使用父类的成员，如果他不先完成父类数据的初始化，子类何谈继承父类数据以及使用父类数据呢？
        //在每个构造方法中有一条默认语句 super() 这条语句就是去访问父类的空参构造，先调用父类的空参构造方法，完成父类数据的初始化。
        Son son = new Son();

    }
}

class Father extends Object {
    int num = 100;

    public Father() {
        super();
        System.out.println("Father父类的空参构造执行了");
    }
}

class Son extends Father {
    int a = 20;

    public Son() {
        super();
        System.out.println("Son子类的空参构造执行了");
        System.out.println(num);
    }

继承中构造方法的注意事项

A：案例：

父类中没有无参的构造方法，子类怎么办？

a:在子类中添加一个无参的构造方法

b:子类通过super去显示调用父类其他的带参的构造方法

c:本类通过this去调用本类的其他构造方法

本类其他构造也必须首先访问父类构造

B:注意事项

super(…)或者this(…)必须出现在第一条语句上

public class Student {
    public Student(int num) {
        System.out.println("student 有参构造执行了" + num);
    }
}


public class Boy extends Student {
    public Boy() {
        super(10); //必须位于第一行
        System.out.println("boy空参构造执行了");
    }

    public Boy(int num) {
        super(num);
        System.out.println("boy有参构造执行了");

    }
}

看程序写结果

class Fu{
		public int num = 10;
		public Fu(){
			System.out.println("fu"); 
		}
	}
	class Zi extends Fu{
		public int num = 20;
		public Zi(){
			System.out.println("zi"); 
		}
		public void show(){
			int num = 30;
			System.out.println(num);//30
			System.out.println(this.num); //20
			System.out.println(super.num); //10
		}
	}
	class Test {
		public static void main(String[] args) {
			Zi z = new Zi();
			z.show();
		}
	}

class Fu {
		static {
			System.out.println("静态代码块Fu"); //1   

		{
			System.out.println("构造代码块Fu"); //  3
		}

		public Fu() {
			System.out.println("构造方法Fu");   //  4
		}
	}

	class Zi extends Fu {
		static {
			System.out.println("静态代码块Zi");//  2
		}

		{
			System.out.println("构造代码块Zi"); //  5
		}

		public Zi() {
			super();
			System.out.println("构造方法Zi"); //  6
		}
	}
	
	class Test{
		public static void main(String[] args){
			Zi z = new Zi(); //请问执行结果。
		}
	}

继承中成员方法关系

A：案例：

a：当子类的方法名和父类的方法名不一样的时候

b: 当子类的父类名和父类的方法名一样的时候

通过子类调用方法：

a：先看子类中有没有该方法，如果有就使用

b: 在看父类中有没有该方法，有就使用

c:如果没有就报错

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        //zi.hehe();
        zi.haha();
        //方法重写：当子类出现了和父类一模一样（返回值类型一样，方法名一样，形参一样）的方法时，就会发生子类方法覆盖父类方法的现象，这种现象，我们称之为方法重写。
        //所以在调用时，会以子类重写过后的为准。

        //为什么要有方法重写这个机制？


    }
}

class Fu {
    public void fuShow() {
        System.out.println("父类show");
    }

    public void haha() {
        System.out.println("父类的haha方法");
    }
}

class Zi extends Fu {
    public void ziShow() {
        System.out.println("zi show");
    }

    public void hehe() {
        this.ziShow();
        super.fuShow();
        this.fuShow();
    }

    public void haha() {
        System.out.println("子类的haha方法");
    }
}

方法重写概述及其应用

A：什么是方法重写

子类中出现了和父类一摸一样的方法声明（方法名，参数列表，返回值类型），也被称为方法覆盖，方法复写。

B:方法重写的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。

C：案例

a:定义一个手机类。

b:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报

public class MyTest {
    public static void main(String[] args) {
        IPhone iPhone = new IPhone();
        iPhone.call();
    }
}


class Phone {
    public void call() {
        System.out.println("语音通话功能");
    }
}

class IPhone extends Phone {

    //我们通过方法重写，可以扩展父类的功能
    @Override
    public void call() {
        super.call(); //去沿袭父类已经实现好的功能
        System.out.println("视频通话功能");
    }
}

方法重写的注意事项

A：注意

a：父类中私有方法不能被重写

私有的方法无法被继承

b:子类方法重写的时候，访问的权限不能更低

最好是一致的

c:父类的静态方法，不参与重写

B：案例

public class Zi extends Fu {
    //Ctrl+O 重写父类方法
    @Override
    public void hehe(int a, int b) {
        int sum = a + b;
        System.out.println(sum);
    }

    @Override
    protected int haha(int a, int b) {
        int r = a * b;
        return r;
    }

    //@Override 静态方法，不参与重写。
    public static void staticMethod() {
        System.out.println("子类类的静态方法");
    }
}





public class Fu {
    public void hehe(int a, int b) {
        System.out.println("fu hehe");
    }

    protected int haha(int a, int b) {
        System.out.println("fu haha");
        return a + b;
    }

    public static void staticMethod() {
        System.out.println("父类的静态方法");
    }
}






public class MyTest {
    public static void main(String[] args) {
        //方法重载：可以让你在一个类中，定义多个同名方法，要求形参个数或形参类型不同就可以，不拿返回值类型区分。
        //方法重写：要有继承的先决条件，子类出现了和父类一模一样（形参列表，返回值类型，方法名一样）的方法，就会发生方法覆盖现象。
        //方法重写的注意事项：
        //1.父类私有的方法，子类不能重写，父类私有的方法，子类不能继承，何谈重写。
        //2.构造方法，没有重写这一说，父类的构造方法，就是我们在创建子类对象时，想要调用父类构造方法，完成父类数据的初始化。
        //3.静态方法不参与重写。
        //4.子类在重写父类方法的时候，权限修饰符要比父类的高，不能比父类低，或者跟父类一样，你直接点，跟父类一样，永远不会错。


        Zi zi = new Zi();

        Zi.staticMethod();
        Fu.staticMethod();

    }
}

面向对象(猫狗案例分析,实现及测试)

A:猫狗案例分析
	父类的由来:	首先我们需要分析具体的事物,分析完毕以后将共性的内容提取出来放在一个独立的类中(父类).
B:案例演示
	猫狗案例继承版
public class Animal {

    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}


public class Cat extends Animal {

    public void cacheMouse() {
        System.out.println("猫抓老鼠");
    }

    @Override //注解：可以检测该方法是不是重写父类的
    public void eat() {
        System.out.println("我爱吃鱼");
    }
}



public class Dog extends Animal {

    public void lookDoor() {
        System.out.println("狗看门");
    }

    @Override //注解：  这个注解可以检测该方法，是不是重写父类的
    public void sleep() {
        System.out.println("狗白天睡觉");
    }
}




public class MyTest {
    public static void main(String[] args) {
        //方法重写：当子类出现了和父类一模一样（返回值类型一样，方法名一样，形参一样）的方法时，就会发生子类方法覆盖父类方法的现象，这种现象，我们称之为方法重写。
        //所以在调用时，会以子类重写过后的为准。

        //为什么要有方法重写这个机制？
        //子类对父类的功能实现不满意，想要自己去实现，那么子类就提供一个和父类一摸一样的方法，
        // 按照自己的需求去重写，重写过后就会以自己的为准。
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
        dog.lookDoor();

        System.out.println("====================");

        Cat cat = new Cat();
        cat.sleep();
        cat.eat();
        cat.cacheMouse();
    }
}

final关键字概述

A:为什么会有final

由于继承中有一个方法重写的现象，而有时候我们不想让子类去重写父类的方法。这时候我们就可以使用关键字：final

B：final概述

final关键字是最终的意思，可以修饰类，变量，成员方法。

final关键字修饰类，方法以及变量的特点

A：final修饰特点

修饰类：被修饰的类不能被继承

修饰方法：修饰的方法不能被重写

修手机变量: 被修饰的变量不能被重新赋值，因为这个量其实就是一个常量

fin

final关键字修饰局部变量

A：案例

基本类型，是值不能被改变

引用类型，是地址值不能被改变

public class MyTest {

    public final double A = 3.14;
    //公共静态的常量
    //ctrl+shift+U 大小写转换
    public static final boolean FLAG = true;

    public static void main(String[] args) {
        //final最终的，可以修饰成员变量，局部变量，修饰成员方法，修饰类
        //final修饰变量，此变量为一个常量，这就是说的自定义常量。常量名使用大写字母来命名
        //final 修饰方法，此方法不能被子类重写，只能继承。
        //final 修饰类，此类不能被继承。
        final int NUM = 100;


        System.out.println(NUM);

        System.out.println(MyTest.FLAG);

        new Zi().show();


        //final 修饰的是基本数据类型，指的是，值不能再次被改变
        final double B = 3.2;
        // B=3.6;

        //final 修饰引用数据类型，指的是，地址值不能再次被改变。
        final Zi zi = new Zi();
        // zi = new Zi();


    }
}

class Fu {
    public final void show() {
        System.out.println("fu show");
    }
}

class Zi extends Fu {

}

//final 修饰类，此类不能被继承。
final class Father {

}
//报错，不能继承final修饰的类
/*class Son extends Father{

}*/

t.cacheMouse();
}
}


### 

### final关键字概述

A:为什么会有final

		由于继承中有一个方法重写的现象，而有时候我们不想让子类去重写父类的方法。这时候我们就可以使用关键字：final

B：final概述

	final关键字是最终的意思，可以修饰类，变量，成员方法。

### final关键字修饰类，方法以及变量的特点

A：final修饰特点

	修饰类：            被修饰的类不能被继承

	修饰方法 ：         修饰的方法不能被重写

	修手机变量:         被修饰的变量不能被重新赋值，因为这个量其实就是一个常量



		fin

### final关键字修饰局部变量

A：案例

			基本类型，是值不能被改变

			引用类型，是地址值不能被改变

public class MyTest {

public final double A = 3.14;
//公共静态的常量
//ctrl+shift+U 大小写转换
public static final boolean FLAG = true;

public static void main(String[] args) {
    //final最终的，可以修饰成员变量，局部变量，修饰成员方法，修饰类
    //final修饰变量，此变量为一个常量，这就是说的自定义常量。常量名使用大写字母来命名
    //final 修饰方法，此方法不能被子类重写，只能继承。
    //final 修饰类，此类不能被继承。
    final int NUM = 100;


    System.out.println(NUM);

    System.out.println(MyTest.FLAG);

    new Zi().show();


    //final 修饰的是基本数据类型，指的是，值不能再次被改变
    final double B = 3.2;
    // B=3.6;

    //final 修饰引用数据类型，指的是，地址值不能再次被改变。
    final Zi zi = new Zi();
    // zi = new Zi();


}

}

class Fu {
public final void show() {
System.out.println(“fu show”);
}
}

class Zi extends Fu {

}

//final 修饰类，此类不能被继承。
final class Father {

}
//报错，不能继承final修饰的类
/*class Son extends Father{

}*/

大官人的西门庆

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
构造方法对象的创建步骤static关键字

构造方法/对象的创建步骤/static关键字/继承方inal法的重写/Final构造方法概述和格式A：构造方法的概述和格式创建对象，给对象中的成员进行初始化B:构造方法格式特点 a:方法名与类名一样 b:没有返回值类型，连void都没有 c:没有具体的返回值构造方法的重载及注意事项A：案例构造方法的重载B：构造方法注意事项 a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。 b：如果我们给出了有参数的构造方法，系统将不再提供默认的无参构造方法。
复制链接

扫一扫