Java零基础学习（代码块 继承 方法重载 final关键字）

Java零基础学习（代码块 继承 方法重载 final关键字）

面向对象

• 代码块的概述和分类

  1.概述
  	在Java中，使用{}括起来的代码被称为代码块
  2.代码块分类
  	根据其位置和声明不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块
  3.常见代码块的应用
  	a.局部代码块
  		在方法中出现，限定变量生命周期，及早释放，提高内存利用率
  	b.构造代码块
  		在类中方法外出现，多个构造方法方法中相同的代码存放在一起，每次调用构造都执行，并且在构造方法前执行
  	c.静态代码块
  		在类中方法外出现，加了static修饰；用于给类初始化，在加载的时候就执行，并且只执行一次。
  

  • 代码块的面试题

  看程序写结果
  	class Student {
  		static {
  			System.out.println("Student 静态代码块");  //
  		}
  		
  		{
  			System.out.println("Student 构造代码块");//
  		}
  		
  		public Student() {
  			System.out.println("Student 构造方法");//
  		}
  	}
  
  	class StudentDemo {
  		static {
  			System.out.println("StudentDemo的静态代码块"); //
  		}
  		
  		public static void main(String[] args) {
  			System.out.println("我是main方法"); //
  		
  			Student s1 = new Student();
  			Student s2 = new Student();
  		}
  	}
  	答：StudentDemo的静态代码块
  		我是main方法
  		Student 静态代码块
  		Student 构造代码块
  		Student 构造方法
  		Student 构造代码块
  		Student 构造方法
  

• 继承的引入和概述

  1.概述
  	多个类中存在相同的属性和行为是，将这些属性和行为内容抽取到单独的一个类中，那么多个类无需再定义这些属性和行为，只需要继承那个类即可。
  2.继承格式
  	通过extends关键字可以实现类与类的继承
  	class 子类名 extends 父类名{}
  	单独的这个类成为父类，基类或者超类；多个类可以称为子类或者派生类
  

  • 继承的好处和弊端

  1.好处
  	a:提高了代码的复用性
  	b:提高了代码的维护性
  	c:让类与类之间产生了关系，是多态的前提
  2.弊端
  	类的耦合性增强了
  

  • Java中类的继承特点

  1.Java中只支持单继承，不支持多继承，一个子类只能有一个父类
  2.Java支持多层继承，父类也可以有父类。
  

  • 继承的注意事项

  1.继承的注意事项
  	a.子类只能继承父类所有的非私有成员（成员变量和成员方法）
  	b.子类不能继承父类的构造方法，但是可以通过super关键字取访问父类的构造方法。
  	c.不要为了部分功能去继承
  2.什么时候使用继承
  	继承其实体现的是一种关系：“is  a”。
  	假如有两个类A,B。只要他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承
  

• 继承中成员变量的关系

  1.子类中的成员变量和父类中的成员变量名称不一样就正常访问。
  2.子类中的成员变量和父类中的成员变量名称一样。
  	在子类中访问的一个变量的查找顺序（就近原则）
  		a.在子类的方法的局部范围找，有就使用
  		b.在子类的成员范围找，有就使用
  		c.在父类的成员范围找，有就使用
  		d.如果还没有，就报错
  

  • this和super的区别和应用

  1.通过问题引出super
  	子类局部范围访问父类成员变量
  	当子类成员变量和父类成员变量名称一样时，子类的成员变会隐藏父类的变量
  2.说说this和super的区别
  	this	代表的是本类对象的引用
  	super	代表的是父类存储空间的标识（可以理解成父类的引用，可以操作父类的成员）
  3.this和super的使用
  	a.调用成员变量
  		this.成员变量	调用本类中的成员变量
  		super.成员变量	调用父类中的成员变量
  	b.调用构造方法
  		this(...)		调用本类中的构造方法
  		super(...)		调用父类中的构造方法
  	c.调用成员方法
  		this.成员方法		调用本类的成员方法
  		super.成员方法		调用父类的成员方法
  		举例：
  class Animal {
      String name;
      int age;
      public void run(String name){
          System.out.println(name+"可以跑步");
      }
      public void eat(){
          System.out.println("吃饭");
      }
  }
  
  class Dog extends Animal{
      String name="阿黄";
      public void eat(){
          System.out.println("狗吃骨头");
      }
      public static void lookDoor(){
          System.out.println("狗可以看门");
      }
      public void run(String name){
          System.out.println(name+"可以跑步");//name代表的是形参中的name
          System.out.println(this.name+"可以跑步");//name代表的是本类中的成员变量
          System.out.println(super.name+"可以跑步");//name代表的是父类中的name
      }
      public void haha(){
          this.eat();  //本类中的eat方法
          super.eat(); //父类中的eat方法
      }
  }
  
  class MyTest {
      public static void main(String[] args){
          Dog dog = new Dog();
          String name=dog.name;
          int age=dog.age;
          name="旺财";
          age=4;
          dog.run(name);
          dog.eat();
          System.out.println(name);
          System.out.println(age);
          dog.haha();
      }
  }
  输出：旺财可以跑步
  	阿黄可以跑步
  	null可以跑步
  	狗吃骨头
  	旺财
  	4
  	狗吃骨头
  	吃饭
  

  • 继承中构造方法的关系

  1.子类中的构造方法都会默认访问父类中的空参构造方法
  2.为什么呢？
  	因为子类会继承父类中的数据，可能还会使用父类中的数据。
  	所以子类在初始化前，一定要先完成父类的初始化。
  其实，每一个构造方法的第一句默认语句都是：super()
  

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

  1.父类没有无参构造方法，子类怎么办？
  	a.在父类中加一个无参的构造方法
  	b.子类通过super去显示调用父类其他带参的构造方法
  	c.子类通过this去调用本类的其他构造方法（本类的其他构造方法必须先访问了父类构造）
  2.注意事项
  	super(...)或者this(...)必须出现在第一条语句上
  

  • 继承中的面试题

  	看程序写结果1
  	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();
  		}
  	}
  答：fu zi 30 20 10
  	看程序写结果2
  	class Fu {
  		static {
  			System.out.println("静态代码块Fu"); 
  		}
  
  		{
  			System.out.println("构造代码块Fu"); 
  		}
  
  		public Fu() {
  			System.out.println("构造方法Fu");  
  		}
  	}
  
  	class Zi extends Fu {
  		static {
  			System.out.println("静态代码块Zi");
  		}
  
  		{
  			System.out.println("构造代码块Zi"); 
  		}
  
  		public Zi() {
  			super();
  			System.out.println("构造方法Zi"); 
  		}
  	}
  	
  	class Test{
  		public static void main(String[] args){
  			Zi z = new Zi(); //请问执行结果。
  		}
  	}
  答：静态代码块Fu
  	静态代码块Zi
  	构造代码块FU
  	构造方法Fu
  	构造代码块Zi
  	构造方法Zi
  

• 继承中成员方法的关系

  1.当子类的方法名和父类的不一样时，正常调用
  2.当子类的方法名和父类的方法名一样时
  	通过子类调用方法
  		先查找子类中有没有该方法，如果有就使用
  		再查找父类中有没有该方法，如果有就使用
  		如果都没有就报错
  

  • 方法重写概述及其应用

  1.什么是方法重写
  	子类出现和父类一模一样的方法声明（方法名，参数列表，返回值类型），也被成为方法覆盖，方法重写。
  2.方法重写的应用：
  	当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类中的方法。
      这样，既沿袭了父类的功能，又定义了子类特有的内容
  public class Test {
      public static void main(String[] args) {
          Dog dog = new Dog();
          dog.eat();
      }
  }
  class Animal{
      public void eat(){
          System.out.println("吃饭");
      }
  }
  class Dog extends Animal{
      public void eat(){
          System.out.println("狗吃骨头");
      }
  }
  输出的是狗吃骨头。
  

  • 方法重写的注意事项

  1.父类中的私有方法不能被重写
  	因为私有方法都不能被继承
  2.子类重写父类方法时，访问权限不能更低，最好一致
  3.父类静态方法不参与重写
  

  • final关键字概述

  1.为什么会有final
  	由于继承中有方法重写的现象，而有时候我们不想让子类去重写父类的方法，对这种情况Java就提供了一种关键字：final
  2.final概述
  	final关键字是最终的意思，可以修饰类，变量，成员方法。
  

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

  修饰类：	被修饰的类不能被继承
  修饰方法：	被修饰的方法不能被重写
  修饰变量：	被修饰的变量不能被重新赋值，这其实也就是一个常量
  

  • final关键字修饰局部变量

  修饰基本类型，值不能被改变，修饰引用类型，地址值不能被改变。
  

  总结

  今天我们学习了代码块的概述和分类，类的继承和其注意事项，方法重写和final关键字，一定要分清楚方法重写和方法重载的区别，final修饰类 成员方法 成员变量的特点也一定要记住

Java零基础学习（代码块 继承 方法重载 final关键字）

原文：https://www.cnblogs.com/N-jack/p/14719214.html