本文详细介绍了Java中的代码块分类及其执行顺序，并探讨了继承的概念、特点与使用方法，包括构造方法的调用规则、this与super关键词的用法等。
1. 代码块分类 : 根据其位置和声明不同: 一.局部代码块: 二.构造的代码块 三.静态代码块 四 同步代码块
执行顺序: static{静态代码块} > {构造代码块}> public class(){无参构造方法}=public class(int a){有参构造方法}构造方法:每次调用类构造方法都会被执行,初始化成员变量的;
class CodeBlock{
int a;
public void function1(){
{
//局部代码块,限制变量的作用域
int num =10;
}
}
public void (){
sout("我是无参构造方法")
}
public void (int a){
this.a = a;
sout("我是有参构造方法")
}public void sayHi(){
sout("我的名字是----"+name)
}
//我是构造代码块我和局部代码块的区别:我位于类中方法外;
{
sout("我是构造代码块,我是第二个执行的")
}
//静态代码块;
static {
sout("我是静态代码块,我是第一个执行的")
}
}
public class Demo01代码块 {
public static void main(String[] args) {
Person p1 = new CodeBlock();
p1.name = "啊狼";
p1.sayHi();
Person p2 = new Person("阿狗");
p2.sayHi();
}
这时候执行的的结果是:
.我是静态代码块,我是第一个执行的
"我是构造代码块,我是第二个执行的" 我是无参构造方法 我的名字是啊狼
"我是构造代码块,我是第二个执行的"
我的名字是阿狗
构造代码块 :只要创建对象就会被调用;是由系统自己调用的;静态代码调用后就被调用
代码块:在Java中 使用 { } 括起来的代码成为代码块:
局部代码块: 位置:方法中 作用:限制作用域,以及限制变量的生命周期;
构造代码块 位置:类中方法外 每次调用构造方法执行前,都会先执行构造代码块;
作用:可以把多个构造方法的共同代码放在一起;
静态代码块: 位置: 类中; 格式: static{ } 作用:一般是对类进行初始化.
2.继承(extends) 格式: class A extends B { }(a 继承b的属性和方法)
1. 继承是可以传递的;
2.继承的是属性和行为;
3.建立类和类之间的关系;
继承的好处 : 提高代码的复用性; 提高类和类之间的关系;
继承的弊端: 违反了高内聚低耦合的追求;
java 中:1. 只能允许单继承(但是可以通过接口实现多继承;)
2. 允许多层继承(继承链子) a继承b b继承c;
3.一般使用继承连最顶端的类:
4.如果一个类没有写继承,默认是继承Object类(是java中最顶端的类 基类)
class Test{
public static void main(String[] args){
Demo1 a = new.Demo1;
sout(a.toString()); //由于继承了Object里面的toString方法;才有了这个方法;
}
}
class Demo1{ //默认是继承了Object类 =Demo1 extends Object{ }
}3.继承中的构造方法
1:注意构造方法在继承过程中是不会被继承了,但是系统会帮你调用一次父类的无参构造方法
2.你也可以自己掉用一次;
public class Test{
public static void main(String[] args) {
//Son son = new Son("zhangsan"); //构造方法无法继承;
Son son =new Son(); //执行到这一句的时候
//会执行:我是Father的无参构造方法
// 我是Son的无参构造方法;
System.out.println("--------");
Son son1 = new Son("彭倩");//执行到这里的时候同样;
//会执行:我是Father的无参构造方法
// 我是Son的无参构造方法;换句话说:只要你用Son类创建一个对象如果父类有无参构造方法;系统就会帮你调用一次父类的无参构造方法;
}
//首先我们先构建一个父类:父类里面有有参构造方法和无参构造方方法;
class Father{
String name; //这是父类的属性
public Father() {
System.out.println("我是Father类的无参构造方法");
}
public Father(String name) {
this.name = name;
System.out.println("我是Father类的有参构造方法");
}
public void sayHi() { 这是父类的方法;
System.out.println(name);
}
}
//接着我们构建一个儿子类:同样儿子类里面有有参构造和无参构造方法;
class Son extends Father {
public Son() {
// 系统帮你在构造方法的第一行 写了一句代码;
super(); // 调用了父类的构造方法;你不写系统会帮你加上;(super可以写也可以不写)反正就是系统一定要帮你调用一次父类无参构造方法;
System.out.println("我是Son类无参构造方法");// 在这句话之前打印父类无参构造;
}
public Son(String name) {
super();// 也会调用父类的构造方法 这一行代码是被隐藏起来的
// super(name); 假如父类没有无参构造函数;这个super你必须要写;并且传入一个参数;系统没法帮你调用父类的无参构造方法; 父类有有参;你要自己调用
this.name = "name";
System.out.println("我是有参构造方法");
}
}4.关于this和super
1. super 在子类中代表父类的对象:(super作为对象:可以调用父类的方法和属性)
2.this在子类中调用子类的属性和方法;
public class Demo06super和this关系 {
public static void main(String[] args) {
TestB testB = new TestB(); //此处用子类创建了一个对象;
testB.print();
}
}
class TestA{
int num1 = 10;
int num2 =20;
public void fun() {
System.out.println("我是父类方法");
}
}
class TestB extends TestA{
int num2 = 50;
public void print() {
System.out.println(this.num1); //这里用this调用子类的属性;
System.out.println(this.num2);
//直接调用父类的属性可以使用super 关键词; super 代表父类对象
System.out.println(super.num2); //这里使用super 调用了父类的数次那个;
//super 也可以调用父类的方法;
super.fun(); //此处用super 调用了父类的方法;
}
}5.关键词final;
package com.lanou3g;
import java.time.format.TextStyle;
/*
* 关键字 final(绝育)
* 1.修饰方法 方法不能被重写
* 2.修饰类 类不能被继承
* 3.修饰变量 变量不能被修改
* final 修饰 引用数据类型
* 不能进行重新指向(地址不能修改了)
* 对象中的属性不会影响修改
*/
public class Demo09关键字final {
public static void main(String[] args) {
//final int num=10;
//num=20;
//如果在TestE前面加上final 就会下面一行就会报错
final TestE testE= new TestE(); //没创建一次对象就会执行一个构造方法;
testE = new TestE();
}
}
class TestE{
//堆内存分配默认值 是无效的默认
//final 修饰成员变量的时候 需要赋 初始值
//赋值 初始值 三种方式
//一般使用final的时候 会直接 定义成 静态常量
//使用类名直接调用 方便
//常量的命名规范 所有字母大写 多单词用下划线分开
public static final int MAX_VALUE=10;//num默认值为0
public final void fun() {
//num=20;
}
public TestE() {
//可以在构造方法中 进行赋值
//num=10;
System.out.println("我是无参构造方法");
}
{
//可以在构造代码块中 进行赋值
//num=10;
}
}
class TestF extends TestE{
}6.方法的重写
package com.lanou3g;
/*
* 方法重载(Overload)(在一个类中进行;)
*
* 方法重写(Override)(前提:至少两个类 并且有继承关系)
* 方法重写: 跟父类的方法完全一致;
* 作用:相当于对父类的该方法进行升级;
*
* 书写一个类 都写什么方法
* 构造方法 set/get 方法
* 重写 to String 方法;
*
*
* 老师类 把相同的属性和行为提出去 学生类
* 无参 有参构造 set/get方法 成员变量私有化 介绍自己的方法
属性:姓名,年龄
* 行为:吃饭
* 老师有特有的方法:讲课
* 学生有特有的方法:学习
*
*/
public class Demo08方法的重写 {
public static void main(String[] args) {
TestD testD = new TestD();
testD.print();//这时调用的是D类的print方法;
}
}
class TestC{
String name;
public void print() {
System.out.println("我是C类 print方法"+name);
}
}
class TestD extends TestC{
public void print() {
//重写父类方法的时候,调步调父类的方法根据你的需求;
//iso7 siri 只会说英文 ISO8 英文中文都能说了;
super.print();//代表在调用父类的方法;用superl
System.out.println("我是D类 print方法");
ISO8 iso8 = new ISO8();
//为什么打印对象 希望直接把这个类的属性输出出来;
System.out.println(iso8);
}
}
class ISO7{
public void siri() {
System.out.println("说英文");
}
}
class ISO8 extends ISO7{
String name = "瓦罗兰的太阳";
@Override // 注解:标识这个方法是重写父类;
public void siri() {
super.siri();//先调用一下父类;让他说英文;
System.out.println("说中文");
}
//这个方法一般用来输出 本类中的属性;
@Override
public String toString() { //说明重写了 它父类Object的to string可以重写
// 调用的是父类的方法
//打印出来是 全类名+@+16进制的hashcode吗;
return "我就想看看属性"+"__--"+name;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
