java中的 继承 重写 封装 super关键字

block 块 { }

• { } 定义在方法中–>局部代码块或者普通语句块 执行时机: 方法调用时

• { } 定义在类中方法外–>构造块 执行时机: 创建对象的时候

• static{ } 定义在类中方法外–>静态块 **执行时机:**类第一次加载时

• { }就是一个作用域

• 构造块中代码先于构造器代码执行,如果有多个构造块,从上到下依次执行

• static只执行一次,在类第一次加载后执行,如果存在多个静态块,从上到下依次执行

执行顺序: static->main方法–>构造块–>构造器

=======================================================================================

导包

• 导包需要关键字 import 标识当前所使用的这个类的位置

  • 模糊匹配（会将该包下所有用到的类引入进来），
    会降低编译速度，但是不会影响运行速度

import java.util.Scanner;//导包
import java.util.*;//模糊匹配（会将该包下所有用到的类引入进来），
				会降低编译速度，但是不会影响运行速度

不需要使用 import 的类有
1、 语言包 （java.lang）下的类
2、 同包下的类

JDK 中常用的包简单介绍：

①java.lang –语言包：语言中常用的功能，如 String、Math、
System、Integer、Thread… ②java.util – 工具包：提供一些实用的工具类，如 容器（List、
Set、Map…）,日期类
③java.io – 输入输出包：提供操作读取文件的相关类，如 File、
InputStream、OutputStrem… ④ java.net – 网络包 ： 操 作 远 程 资 源 的 类 ， 如
InetSocketAddress、 DatagramPacket 、ServerSocket… ⑤java.sql – 数据库包：操作 JDBC 的类，Connection、Statement、
ResultSet….

=======================================================================================

封装javaBean

public class Person01 {
	public String name;
	private//int age;  //只能在当前类Person01类中使用
	
	public Person01() {
		// TODO Auto-generated constructor stub
	}

	public Person01(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	//设置器  setter
	//返回值:不需要		参数:要 int 
	//成员方法
	public void setAge(int age){
		if(age>=0 && age<=150){
			this.age=age;
		}else{
			System.out.println("年龄不合法...");
		}
		
	}
	
	//获取器
	public int getAge(){
		return this.age;
	}
}
public static void main(String[] args) {
		Person01 p = new Person01("小花,17);
		p.name="小明";
		//p.age=-5;
		p.setAge(18);年龄是私有的,需要调用公共的方法来实现
		System.out.println(p.getAge();
		
	
	}

• 封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和行为（或方法）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
  • 这里介绍一个关键字 private 私有的

关键字private的特性:

1.private 修饰的内容,只能在当前类或者本类中使用

2. 需要为私有的字段提供一对公共的访问方式 设置setter 获取器 getter
3. 私有的属性需要配合公共的访问方式–>方法

私有的属性并且提供公共的访问方式是面向对象中封装特性的体现,
私有是封装,不能说封装是私有,因为封装不仅仅表示为私有

=======================================================================================

封装
隐藏内部的实现细节,并对外提供公共的访问方式

封装的优点：

1. 隐藏实现细节，提供公共的访问方式
2. 提高代码的复用性
3. 提高代码的安全性

 模板类|javaBean|bean...规范

 1. 修饰类的public
 2. 至少提供一个空构造
 3. 属性私有化
 4. 对外提供公共的访问方式  

=======================================================================================

继承extends

• 继承的目的: 为了简化代码

• 继承的特点:

   	 	1.子类一旦继承父类,就可以使用父类的内容
   	 	2.单继承继承:一个子类只能继承一个父类,一个父类可以被多个子类继承,多实现
  

子类|派生类: 继承别的类
父类|基类|超类: 被继承的类

类就是对对象的抽象
父类就是子类的抽象

单继承的优缺点:

      优点:简单
      缺点:不便于后期维护

• 子类是父类的延续+ 扩展 extends
• 子类可以使用父类中的内容,可以定义子类独有的内容

public static void main(String[] args) {
		Teacher th=new Teacher();
		th.subject="数学";
		th.teach();
		th.name="吕进;
		th.age=17;
		
		Student s=new Student();
		s.hometown="日本;
		s.study();
		s.name="小兰";
		s.age=50;
		s.sleep();
		
	}
}

//父类
class Person{
	String name;
	int age;
	
	public void sleep(){
		System.out.println("休息");
	}
}

//子类  教师类
class Teacher extends Person{
	
	String subject;
	
	public Teacher() {
		// TODO Auto-generated constructor stub
	}
	
	public void teach(){
		System.out.println("每天上课都讲数学");
	}
	
	
}

//学生类
class Student extends Person{
	String hometown;
	
	public Student() {
		// TODO Auto-generated constructor stub
	}
	public void study(){
		System.out.println("学习数学,做数学题,学习使我快乐");
	}
/*

使用继承的格式:
			 子类 extends 父类
		上面的代码中,子类是 Student 和Teacher 只需要在子类的类名后加上extends 父类的类名即可完成类的继承
*/

权限修饰符:

权限修饰符的作用:		定义对象中内容的可访问范围	

可以用一个表格来表示谢谢权限修饰符的范围

修饰符名称	本类	同包类	不同包的子类	不同包的其他类
public	Y	Y	Y	Y
protected	Y	Y	Y
default(默认的)	Y	Y
private	Y

特点:

• ​ 都是成员修饰符,不能修饰局部;
• ​ default关键字默认的,省略不写;
• ​ 能够修饰类的只能为public | default;

能够使用被protected修饰的内容的方式:

• 不同包下的
• 不同包下的子类中才能够使用,并且必须通过子父类继承的关系使用才可以

​ =======================================================================================

Override 重写

 * 重写和重载之间区间:
 * 	无论是重写还是重载都是只的方法而言
 * 
 *  方法的重载:
 *  	同一个类中的多个方法
 *  	方法名相同
 *  	参数列表不同
 *  
 *  方法的重写:
 *  	1.不同的类
 *  	2.继承|实现
 *  	3.方法签名相同
 *  
 *  如果子父类中构成方法的重写,子类对象调用时候会调用子类中重写的那个方法,对父类的方法进行屏蔽
 *  
 *  检测方法重写的方式:
 *  	1.左侧会出现向上的三角形
 *  	2.@Override 注解强制检查重写方法
 *  
 *  == 方法签名完全相同
 *  <= 返回值类型: 返回值类型为基本数据类型要求必须相同, 如果引用数据类型,子类<=父类
 *  >= 子类权限修饰符>=父类权限修饰符
 *  
 *  注意:
 *  	被private修饰的方法不能被重写
 *  	被final关键字修饰的方法不能被重写
 *  	被static修饰的方法不能被重写
 *  		但是注意:如果子类中有与父类中的某个静态方法同名的时候,那这个方法也要为static修饰的

public class Override {
	public static void main(String[] args) {
		JianLin j=new JianLin();
		j.name="王健林";
		j.works();
		SiCong Si =new SiCong();
		Si.name="王思聪";
		Si.works();
	}
}
class JianLin{
	public String name;
	public void works(){
		System.out.println(name+"说:先定一个小目标,挣它一个亿!!!");
	}
}
class SiCong extends JianLin{
	
	public void works(){
		//super.works();
		System.out.println(name+"说:我不在乎我的朋友们有没有钱,反正都没有我有钱!!!");
	}
}
/*
以上代码中,SiCong继承了JianLin类,他就拥有了JianLin类中的works()方法,但是,SiCong里方法我不满意,那么可以重写.重写的条件是:
1.是不同的类之间,
2.类与类之间必须要有继承关系
3.方法签名相同

如果子父类中构成方法的重写,子类对象调用时候会调用子类中重写的那个方法,对父类的方法进行屏蔽

以上代码运行的结果为:
王健林说:先定一个小目标,挣它一个亿!!!
王思聪说:我不在乎我的朋友们有没有钱,反正都没有我有钱!!!(输出的是重写后的方法)

*/

super关键字

super:指代父类对象
 *  	1.调用父类的构造器
 *  		super()
 *  		如果没有显示定义,调用父类的哪一个构造器,默认首行调用super()父类空构造
 	   	 ***因为一般子类构造器的首行会默认调用父类空构造的问题,所以建议模板类都至少存在一个空构造
 *  		super()必须在首行调用使用才行
 *  
 *  	2.区分子父类同名问题
 *  		如果当子父类中存在同名成员的时候,子类中使用同名内容默认就近原则指代父类,如果先要使用父类的通			   过super使用
 *  			super指代父类对象
 *  		如果不存在同名问题,调用父类中的成员,super.可以省略
 *  
 *  先父类后子类
 *  先静态后成员
    创建子类对象之前,要先创建父类对象-->先子类后父类(父类对象在子类对象内存空间中的,外部无法直接操作,只能	  在子类中通过super使用这个内部的父类对象)
    初始顺序:先静态后成员
 *  
 *  final 关键字
 *  	被final修饰的变量为常量
 *  	被final修饰的方法不能被重写
 *  	被final修饰的类不能被继承 (太监类)
		
 //	测试 Super 默认调用父类构造器
public class SuperTest {
	public static void main(String[] args) {
		//创建子类对象
		//默认先创建父类,然后在创建子类
		Son s=new Son();		
	}
}
class Father{

	public Father() {
		
		System.out.println("我是父类空构造");
	}
	
}
class Son extends Father{

	public Son() {		
        super();//可以省略,如果不写,默认调用父类的构造器
		System.out.println("我是子类空构造");
	}
	
}
/*
以上代码输出结果为:
我是父类空构造
我是子类空构造

因为如果没有显示定义,调用父类的哪一个构造器,默认首行调用super()父类空构造,
*/
        

 //依然还是用 王建林 和王思聪来举例
    
    public class Override {
	public static void main(String[] args) {
		JianLin j=new JianLin();
		j.name="王健林";
		j.works();
		SiCong Si =new SiCong();
		Si.name="王思聪";
		Si.works();
	}
}
class JianLin{
	public String name;
	public void works(){
		System.out.println(name+"说:先定一个小目标,挣它一个亿!!!");
	}
}
class SiCong extends JianLin{
	
	public void works(){
		super.works();
		System.out.println(name+"说:我不在乎我的朋友们有没有钱,反正都没有我有钱!!!");
	}
}
/*
以上代码输出结果为:
王健林说:先定一个小目标,挣它一个亿!!!
王思聪说:先定一个小目标,挣它一个亿!!!
王思聪说:我不在乎我的朋友们有没有钱,反正都没有我有钱!!!

因为子父类中构成方法的重写,子类对象调用时候会调用子类中重写的那个方法,对父类的方法进行屏蔽,但是如果想要在子类中,调用父类中的方法,那么只需要super. 就可以了.如上面的代码中子类SiCong中的用super.works()来调用父类中的方法.
*/