this关键词的使用
1.this可以用来修饰、调用：属性、方法、构造器
2.this修饰属性和方法：
this理解为：当前对象 或 当前正在创建的对象
* 2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
class person{
private String name;
public String getName(){
return this.name; //通过this.属性，调用当前对象的属性（该this可加可不加，因为方法没有形参）
}
public void setName(String name){
this.name = name; //该this必须加，因为方法的形参和类的属性同名
}
public void eat(){
System.out.println("人吃饭");
}
public void study(){
System.out.println("人学习");
this.eat(); //通过this.方法名，调用当前对象的方法
}* 2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
class person{
private String name;
public person(){};//空参构造
public person(String name) {
this.name = name; //该this必须加，因为构造器的形参和类的属性同名
this.eat();//通过this.方法名，调用当前正在创建的对象方法
}
public void eat(){
System.out.println(name +"吃饭");
}
}this调用构造器
① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
② 构造器中不能通过"this(形参列表)"方式调用自己
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"
④ 规定："this(形参列表)"必须声明在当前构造器的首行
⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器
class person{
private String name;
public person(){
System.out.println("空参构造");
};
public person(String name) {
//this(name);//不能调用自己
this();//调用空参构造器
this.name = name;
this.eat();
}
}import关键字的使用
1. 在源文件中显式的使用import结构导入指定包下的类、接口
2. 声明在包的声明和类的声明之间
3. 如果需要导入多个结构，则并列写出即可
4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
import java.util.*;5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
6. 如果使用的类或接口是本包下定义的，则可以省略import结构
7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
com.xm.exer.Account acct1 = new com.xm.exer.Account("小明",18);//全类名的方式显示8. 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
9. import static:导入指定类或接口中的静态结构:属性或方法。
import static java.lang.Math.*;package关键字的使用
1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在源文件的首行
3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
4.每"."一次，就代表一层文件目录。
补充：同一个包下，不能命名同名的接口、类。 不同的包下，可以命名同名的接口、类。
Java_JDK中主要包介绍
1. java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和 Thread，提供常用功能
2. java.net----包含执行与网络相关的操作的类和接口。
3. java.io ----包含能提供多种输入/输出功能的类。
4. java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日 期日历相关的函数。
5. java.text----包含了一些java格式化相关的类
6. java.sql----包含了java进行JDBC数据库编程的相关类/接口
7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这 些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S
super关键词使用
定义和作用
1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器
super的使用——调用属性和方法
1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用
父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则 必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法 时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
super调用构造器
1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器
public class Person {
private String name;
public Person(){};
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("Person类定义方法");
}
}
class Student extends Person{
String major;
public Student() {
super();
}
public Student( String major){
super();//默认调用父类空参构造器[在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()]
this.major = major;
}
public Student(String name, String major) {
super(name);//调用父类Person的形参为name的构造器
this.major = major;
}
public void show(){
System.out.println("Student类定义的方法");
}
public void study(){
this.show();//调用自己重写的show方法
super.show();//调用父类Person的show方法
}
}
class SuperTest{
public static void main(String[] args) {
Student s = new Student();
s.show();
s.study();
}
}
//运行结果：
//Student类定义的方法
//Student类定义的方法
//Person类定义方法this和super的区别
| 区别点 | this | super |
| 访问权限 | 优先访问本类中的属性，如果本类没 有此属性则从父类中继续查找 | 直接访问父类中的属性 |
| 调用方法 | 优先访问本类的方法，如果本类没有此方法则从父类中继续查找 | 直接访问父类中的方法 |
| 调用构造器 | 调用本类构造器，必须放在构造 器的首行 | 调用父类构造器，必须 放在子类构造器的首行 |
instanceof关键词使用
使用说明
a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
使用情境
为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
如果 a instanceof A返回true,则 a instanceof B也返回true. 其中，类B是类A的父类。
public class PolymorphismTest{
public static void main(String[] args) {
Person p1 = new Student();
if (p1 instanceof Student) { //true
Student s = (Student) p1;
s.setName("张三");
s.major = "数学"; //向下转型后，就可以调用子类特有的属性
s.study(); //向下转型后，就可以调用子类特有的方法
s.eat();
}else{
System.out.println("ClassCastException的异常");
}
}
}
class Person {
private String name;
public Person(){};
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void eat(){
System.out.println(name +"吃饭");
}
public void walk(){
System.out.println("人走路");
}
}
class Student extends Person{
String major;
public Student() {
super();
}
public Student( String major){
super();
this.major = major;
}
public Student(String name, String major) {
super(name);
this.major = major;
}
public void eat(){
System.out.println(getName() +"吃学校的饭");
}
public void study(){
System.out.println("学生学习的专业：" + major);
}
}
//运行结果：
//学生学习的专业：数学
//张三吃学校的饭
static关键词的使用
1.static:静态的
2.static可以用来修饰：属性、方法、代码块、内部类
3.使用static修饰属性：静态变量（或类变量）
3.1 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
3.2 static修饰属性的其他说明：
① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
② 静态变量的加载要早于对象的创建。
③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
④ 类变量 实例变量
类 yes no
对象 yes yes
4.使用static修饰方法：静态方法
① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
② 静态方法 非静态方法
类 yes no
对象 yes yes
③ 静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
5. static注意点：
5.1 在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
6. 开发中，如何确定一个属性是否要声明为static的？
> 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
> 类中的常量也常常声明为static
7. 开发中，如何确定一个方法是否要声明为static的？
> 操作静态属性的方法，通常设置为static的
> 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections
public class Java {
public static void main(String[] args) {
Chinese c1 = new Chinese();
c1.name = "孙杨";
c1.age = 20;
c1.nation = "CHN";
Chinese c2 = new Chinese();
c1.name = "姚明";
c1.age = 35;
c1.nation = "中国";
System.out.println(c1.nation); //中国（当通过c2对象修改静态变量时，会导致c1对象也进行修改。）
System.out.println(c2.nation); //中国
Chinese.eat();//静态方法可以通过（类名.）直接调用
Chinese.nation = "CHINA";//静态方法可以通过（类名.）直接设置
System.out.println(Chinese.nation); //CHINA
}
}
class Chinese{
String name;
int age;
static String nation;
public void sleep(){
System.out.println("非Static方法：睡觉");
}
public static void eat(){
System.out.println("Static方法：吃饭");
// System.out.println(name); // 静态方法中不能调用非静态方法
// sleeep(); //静态方法中不能调用非静态方法
}
public void show(){
// 非静态方法中能调用静态方法和属性（变量）
System.out.println("name=" + name + "age=" + age + "nation" + nation);
sleep();
eat();
}
}final关键词的使用
1. final可以用来修饰的结构：类、方法、变量
2. final 用来修饰一个类:此类不能被其他类所继承。（比如：String类、System类、StringBuffer类）
3. final 用来修饰方法：表明此方法不可以被重写（比如：Object类中getClass();）
4. final 用来修饰变量：此时的"变量"就称为是一个常量
4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化 （需要在所有构造器均进行初始化） 4.2 final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
5. static final 用来修饰属性：全局常量
public class FinalTest {
public static void main(String[] args) {
}
final int LONG = 0;
final int WIDTH;
final int LEFT;
//代码块赋值
{
WIDTH = 1;
}
//构造器赋值
public FinalTest(){
LEFT = 1;
}
public FinalTest(int n){
LEFT = n;
}
//不能给final修饰的最终变量再次赋值
// public void setLONG(int LONG){
// this.LONG = LONG;
// WIDTH = 10;
// }
public void show(final int NUM){
// NUM = 20; //final修饰的形参 不能在重新赋值
}
}
//被final修饰的类Final2不能被继承
//final class Final1 extends Final2{
// public void other(){
// System.out.println("final修饰的类");
// }
//}
final class Final2 extends Final3{
public void other(){
System.out.println("final修饰的类");
}
//不能重写Final3中定义的被final修饰的方法
// public void finalDemo(){
// System.out.println("是否能给重写final修饰的方法");
// }
}
class Final3{
final public void finalDemo(){
System.out.println("final修饰的方法");
}
}abstract关键词的使用
1.abstract可以用来修饰的结构：类、方法
2. abstract修饰类：抽象类
> 此类不能实例化
> 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
> 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
3. abstract修饰方法：抽象方法
> 抽象方法只有方法的声明，没有方法体
> 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
> 若子类重写了父类中的所有的抽象方法后，此子类方可实例化
>若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰 4. abstract使用上的注意点：
4.1 abstract不能用来修饰：属性、构造器等结构
4.2 abstract不能用来修饰私有方法、静态方法、final的方法、final的类
public class AbstractTest {
public static void main(String[] args) {
// person p = new person(); //抽象类不能被实例化
student s = new student("张三",23);
System.out.println(s); //student{name='张三', age=23}
s.breath(); //学生呼吸
}
}
abstract class Creature{
public abstract void breath();
// private abstract void breath1(); //abstract 不能修饰私有方法
}
abstract class person extends Creature{
String name;
int age;
public person() {}
public person(String name, int age) {
this.name = name;
this.age = age;
}
//抽象方法
public abstract void eat();
public void walk(){
System.out.println("走路");
}
}
class student extends person{
public student() {}
public student(String name, int age) {
super(name, age);
}
@Override
public void breath() {
System.out.println("学生呼吸");
}
@Override
public void eat() {
System.out.println("学生吃饭");
}
@Override
public String toString() {
return "student{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}说明：本篇文章部分内容和图片引用尚硅谷官网内容，特此说明。@尚硅谷官网地址