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修饰类 成员方法 成员变量的特点也一定要记住

posted @ 2021-04-29 18:22  Jack+_+  阅读(109)  评论(0)    收藏  举报