Java面对对象第三天(代码块--继承--this和super--关键字final--方法重写--)

本文详细介绍了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;
    } 
}
Java语言中的关键字是指具有特殊含义的单词,这些单词在Java程序中具有特定的用途,不能作为标识符或变量名使用。Java中共有50个关键字,其中包括48个保留关键字2个特殊关键字。 以下是Java中的各种关键字: 1. abstract:用于定义抽象类抽象方法。 2. assert:用于调试程序时进行断言判断,如果条件不成立将会抛出AssertionError异常。 3. boolean:用于定义布尔类型变量,只能取值true或false。 4. break:用于跳出循环语句。 5. byte:用于定义字节类型变量,取值范围为-128到127。 6. case:用于在switch语句中匹配选项。 7. catch:用于捕获异常。 8. char:用于定义字符类型变量。 9. class:用于定义类。 10. const:Java虽然保留了此关键字,但并没有使用,因此不能用于定义常量。 11. continue:用于跳过循环中的某个迭代。 12. default:用于switch语句中的默认选项。 13. do:用于定义do-while循环。 14. double:用于定义双精度浮点类型变量。 15. else:用于if语句中条件不成立时执行的代码块。 16. enum:用于定义枚举类型。 17. extends:用于继承一个类或实现一个接口。 18. final:用于定义常量或不可变的变量,或者修饰类、方法、变量等,表示其不可再被继承重写或修改。 19. finally:用于定义无论是否有异常发生都需要执行的代码块。 20. float:用于定义单精度浮点类型变量。 21. for:用于定义for循环。 22. goto:Java虽然保留了此关键字,但并没有使用,因此不能跳转到标签。 23. if:用于定义条件语句。 24. implements:用于实现一个接口。 25. import:用于导入其他类的定义。 26. instanceof:用于判断一个对象是否属于某个类或实现了某个接口。 27. int:用于定义整型变量。 28. interface:用于定义接口。 29. long:用于定义长整型变量。 30. native:用于调用本地方法。 31. new:用于创建一个对象。 32. package:用于定义包。 33. private:用于定义私有成员,只能在当前类中访问。 34. protected:用于定义受保护的成员,只能在当前类及其子类同一个包中访问。 35. public:用于定义公共成员,可以被任何类访问。 36. return:用于从方法中返回值。 37. short:用于定义短整型变量。 38. static:用于定义静态成员,只有一个拷贝,可以通过类名直接访问。 39. strictfp:用于声明浮点数计算具有严格的规范化行为。 40. super:用于引用父类的成员。 41. switch:用于定义switch语句。 42. synchronized:用于定义同步方法或同步代码块。 43. this:用于引用当前对象。 44. throw:用于抛出异常。 45. throws:用于声明方法可能抛出的异常。 46. transient:用于声明不需要持久化的变量。 47. try:用于定义异常处理代码块。 48. void:用于定义无返回值的方法。 49. volatile:用于声明变量是易变的,即每次访问都需要从主存中读取。 50. while:用于定义while循环。 以上就是Java中的各种关键字,这些关键字Java程序中起着非常重要的作用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值