Java学习---面向对象--关键字

Java学习
面向对象

一、package关键字

1. package其实就是类的命名空间，用来唯一标识这个类的，避免和的类的名字重复
2. 每创建一个java文件首行的对象，一个标识符

二、import关键字
import：导入

1. 导入各种各样的结构：包、类、接口等等
2. 声明在package(包)的声明和类的声明之间
3. 如果需要导入多个结构，则并列写出即可
4. 可以使用"xxx.*"的方式，表示导入xxx包下的所有结构
5. 如果使用的类或接口是java.long包下定义的，则可以省略import结构
6. 如果使用的类或接口是本包下定义的，则可以省略import结构
7. 如果在源文件中，使用了不同包下的同名类，则必须至少有一个类需要以全类名的方式显示
8. 如果使用"xxx.*"方式表名可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
9. import static:导入指定类或接口中的静态结构：属性或方法

三、this关键字

1.理解为：当前对象或者当前正在创建的对象
2.用来修饰、调用：属性、方法、构造器
2.1在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。
但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名时，
我们必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参
2.2在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。
但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名时，
我们必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参
3.this修饰调用构造器
① 我们在类的构造器中，可以显式的使用“this(形参列表)”方式，调用本类中指定的其他构造器
② 构造器中不能通过“this(形参列表)”方式调用自己
③ 如果一个类中有n个构造器，则最多有n-1构造器中使用了“this(形参列表)”
④ 规定：“this(形参列表)”必须声明在当前构造器的首行
⑤ 构造器内部，最多只能声明一个“this(形参列表)”，用来调用其他的构造器

四、super关键字
1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器

3.super使用
3.1我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略“super.”
3.2特除情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的方式，表明调用的是父类中声明的属性
3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用“super.方法”的方式，表明调用的是父类中被重写的方法

4.super调用构造器
4.1我们可以在子类的构造器中显式的使用“super(形参列表)”的方式，调用父类中声明的指定的构造器
4.2“super(形参列表)”的使用，必须声明在子类构造器的首行
4.3我们在类的构造器中，针对于“super(形参列表)”或“this(形参列表)”只能二选一，不能同时出现
4.4在构造器的首行，没有显式的声明“super(形参列表)”或者“this(形参列表)”，则默认调用的是父类中空参的构造器：super()
4.5在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类中的构造器

五、instanceof关键字
a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false
要求a所属的类与类A必须是子类和父类的关系，否则编译错误。如果a属于类A的子类B，则返回true。
使用情境：为了避免向下转型是出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型，如果返回false，不进行向下转型。
如果a instanceof A返回true，则a instanceof B也返回true
其中，类B是类A的父类
向下转型：即为强制类型转换

强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
如 float f=(float)12.0; int a=(int)1200L 对Java对象的强制类型转换称为造型
从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过造型(强制类型转换)实现
无继承关系的引用类型间的转换是非法的
在造型前可以使用instanceof操作符测试一个对象的类型
请添加图片描述

六、static关键字

• 1.static：静态的

• 2.static可以用来修饰：属性、方法、代码块、内部类

• 3.使用static修饰属性：静态变量(类变量)

   	3.1	属性，是否使用static修饰，又分为：静态属性(类变量)  /   非静态属性(实例变量)
   	 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中的一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
   	 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时会导致其他对象调用此静态变量时，是修改过的
  
   	3.2 static修饰属性的其他说明
   		① 静态变量随着类的加载而加载，可以通过“类·静态变量”的方式进行调用
   		② 静态变量的加载要早于对象的创建
   		③ 由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中。
   		④ 		类变量           实例变量
   		类		yes			no
   		对象		yes			yes
   	3.3 静态属性举例：System.out; Math.PI;
  

• 4.使用static修饰方法：静态方法
  ① 随着类的加载而加载，可以通过“类·静态方法”的方式进行调用
  ② 静态方法 非静态方法
  类 yes no
  对象 yes yes
  ③ 静态方法中，只能调用静态的方法或者属性
  非静态方法中，即可以调用非静态的方法或者属性，也可以调用静态的方法或者属性

5.static注意点：
5.1 在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，都从生命周期的角度去理解

6.在开发中，如何确定一个属性是否要声明为static？
> 属性可以被多个对象所共有的，不会随着对象的不同而不同的
> 类中的常量也声明为static
在开发中，如何确定一个方法是否要声明为static？
> 操作静态属性的方法，通常设置为static的
> 工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

public class StaticTest {
	public static void main(String[] args) {
		Chinese.nation = "中国";	
		Chinese c1 = new Chinese();
		c1.name = "张三";
		c1.age = 35;
		c1.nation = "CHN";

		Chinese c2 = new Chinese();
		c2.name = "法外狂徒";
		c2.age = 42;
		c2.nation = "CHINA";
		System.out.println(c1.nation);//CHINA	
		//编译不通过
	//	Chinese.name = "李四";	
		c1.eat();
		Chinese.show();//可以直接通过类调用方法	
	//	Chinese.eat();
	//	Chinese.info();
	}
}

class Chinese{
	String name;
	int age;
	static String nation;	
	public void eat() {
		System.out.println("吃饭");
		//调用非静态结构
		this.info();
		System.out.println("name: " + name);
		//调用静态结构
		walk();
		System.out.println("nation: " + nation);
	}
	public static void show() {
		System.out.println("中国人");
		//不能调用非静态的结构
	//	eat();
	//	name = "tom";
		//可以调用静态的结构
		walk();
		System.out.println(Chinese.nation);
	}
	public void info() {
		System.out.println("name:" + name + ",age:" + age);
	}
	public static void walk() {	
	}
}

七、final关键字

• 1.final可以用来修饰的结构：类、方法、变量
• 2.final 用来修饰一个类：此类不能被其它类所继承

•  	比如：String类、System类、StringBuffer类
  

*3.final用来修饰一个方法：表明此方法不可以被重写

•  	比如：Object类中getClass(); 
  

*4.final用来修饰变量：此时的变量变成常量

•  	4.1 final修饰一个属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化
  

•  	4.2 final修饰局部变量：
  

•  			尤其是使用final修=修饰形参时，表明此形参是一个常量，当我们调用此方法时，给常量形参赋一个实参，一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
  

*static final ：用来修饰属性：全局常量

八、abstract关键字

• 1.abstract：抽象的
• 2.abstract可以用来修饰的结构：类、方法
• 3.abstract修饰类：抽象类
  >此类不能实例化
  >抽象类中一定有构造器，便于子类对象实例化调用（涉及：子类对象实例化的全过程）
  >开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
• 4.abstract修饰方法：抽象方法
  >抽象方法只有方法的声明，没有方法体
  >包含抽象方法的类一定是抽象类，反之，抽象类中可以没有抽象方法
  （抽象方法不能调用，因为没有方法体；要想抽象方法不被调用，即不让有该类的对象，则将该类变为抽象类）
  >若子类重写了父类中的所有抽象方法，此子类方可实例化，若子类没有重写父类中的所有抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

九、interface关键字

• 1.接口使用interface来定义
• 2.在Java中，接口和类是并列的两个结构
• 3.如何定义接口：定义接口中的成员

•  	3.1 JDK7及以前：只能定义全局常量和抽象方法
  

•  			>全局常量：public static final的（书写时可以省略不写）
  

•  			>抽象方法：public abstract的
  

•  	3.2 JDK8：出来定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
  

• 4.接口中不能定义构造器，意味着接口不可以实例化
• 5.Java开发中，接口都通过让类去实现(implements)的方式来使用
  如果实现类重写(覆盖)了接口中的所以抽象方法，则此实现类就可以实例化
  如果实现类没有重写(覆盖)接口中所有的抽象方法，则此实现类仍为一个抽象类
• 6.Java类可以实现多个接口 —>弥补了Java单继承性的局限性

•  格式：class AA extends BB implements CC,DD,EE
  

• 7.接口与接口之间可以继承，而且可以多继承
• 8.接口具体使用，体现多态性
• 9.接口，实际上可以看做是一种规范