Java面向对象三：关键字

一、return关键字的使用

1、使用范围：使用在方法中
2、作用：①结束方法 ②针对于有返回值类型的方法，使用“return 数据”方法返回所要数据
3、注意点：return关键字后面不可以声明执行语句

二、关键字：this的使用

1、this可以用来修饰：属性、方法、构造器
2、this修饰属性和方法：
this理解为：当前对象或当前正在创建的对象（构造器）

 2.1在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，通常情况下，我们选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参。
 2.2在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，通常情况，我们选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参。

3、this调用构造器 this调用构造器是为了获取被调用的构造器的内容 this（）；调用空参构造器
this（age）；调用有形参列表的构造器，调用的是形参列表为 public Person(int age){}的构造器 ，age是传参
①我们在类的构造器中，可以显式的使用“this（形参列表）”方式，调用本类中指定的其他构造器
②构造器不能通过“this（形参列表）”方式调用自己 ③如果一个类中有n个构造器，则最多有n-1构造器中使用了“this（形参列表）”
④规定：“this（形参列表）”必须声明在当前构造器的首行 ⑤构造器内部，最多只能声明一个“this（形参列表）”，用来调用其他的构造器

快捷键 Alt+Shift+S----->get、set方法生成
Alt+/---->查看构造器

三、关键字package

package com.atguigu.java;

1、为了更好的实现项目中类的管理，提供包的概念
2、使用package声明类或接口所属的包，声明在源文件的首行
3、包，属于标识符，遵循标识符的命名规则、规范（xxxyyyzzz）、“见名知意”
4、每“.”一次，就代表一层文件目录
补充：同一个包下，不能命名同名的接口、类
不同的包下，可以命名同名的接口、类 -------->主要包的介绍--------------------------------------
java.lang----包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能
java.net-----包含执行与网络相关的操作的类和接口 java.io-------包含能提供多种输入/输出功能的类
java.util-----包含一些实用工具类，如：定义系统特性、接口的集合框架类、使用与日期日历相关的函数
java.text----包含了一些java格式化相关的类 java.sql-----包含了java进行JDBC数据库编程的相关类/接口
java.awt----包含了构成抽象窗口工具集（abstract window
toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI） B/S C/S

四、import关键字的使用

import java.util.Scanner;   包名的某类   导入java.util包下的Scanner类
import：导入

1、在源文件中显式的使用import结构导入指定包下的类、接口
2、声明在包的声明和类的声明之间
3、如果要导入多个结构，则并列写出即可
4、可以使用xxx.的方式，表示可以导入xxx包下的所有结构
5、如果使用的类和接口是java.lang下定义的，则可以省略import结构
6、如果使用的类或接口是本包下定义的，则可以省略import
7、如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示
在主函数中new对象时，需要以包名.类名的方式来创建（不同包下两个同名的类，实例化的时候，不知道是哪个类，一个需要以上述方式来创建实例化）
8、使用“xxx.”的方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式的命名（子包是某一个包下的包）
表示类名和接口 不代表包 9、import static：导入指定类或接口中的静态结构：属性或方法 import
static Math.; Math.sqrt() 可以在主函数中写sqrt（） 最后一个.后面是属性或 方法 类名.；
Math.

五、super关键字

使用super.属性/方法找父类中的属性和方法
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我们在类的构造器中，针对于“this(形参列表)”或“super（形参列表）”只能二选一，不能同时出现
4.4在构造器的首行，没有显式的声明“this（形参列表）”或“super（形参列表）”，则默认调用的是父 类中空参的构造器：super（）
4.5在类的多个构造器中，至少有一个类的构造器中使用了“super（形参列表）”，调用父类中的构造器 5、子类对象实例化过程 ①、从结果上看：（继承性） 子类继承父类以后，就获取了父类中声明的属性或方法
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性 ②、从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用

六、关键字instanceof

Person p2 = new Man();//多态
 Man m1 = (Man)p2;
 m1.earnMoney();
 m1.isSmoking = true;
将所创建的对象类型进行强转，就会具有其属性，方法；在此，Person类型的p2可以被强转为其后所new对象的类型
直接类型提升相当于 多态

import java.util.Date;
public class PersonTest {
   public static void main(String[] args) {
      
      Person p1 = new Person();
      p1.eat();
      
      Man man = new Man();
      man.eat();
      man.age = 25;
      man.earnMoney();
      
      //*************************************************
      System.out.println("*******************");
      //对象的多态性：父类的引用指向子类的对象
      Person p2 = new Man();
//    Person p3 = new Woman();
      //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
      p2.eat();
      p2.walk();
      
      
//    p2.earnMoney();
      
      System.out.println(p2.id);//1001
      
      System.out.println("****************************");
      //不能调用子类所特有的方法、属性：编译时，p2是Person类型。
      p2.name = "Tom";
//    p2.earnMoney();
//    p2.isSmoking = true;
      //有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致
      //编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
      
      //如何才能调用子类特有的属性和方法？
      //向下转型：使用强制类型转换符。
      Man m1 = (Man)p2;
      m1.earnMoney();
      m1.isSmoking = true;
      
      //使用强转时，可能出现ClassCastException的异常。
//    Woman w1 = (Woman)p2;
//    w1.goShopping();
      
      /*
       * instanceof关键字的使用
       * 
       * a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
       * 
       * 
       *  使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
       *  进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
       *  
       *  如果 a instanceof A返回true,则 a instanceof B也返回true.
       *  其中，类B是类A的父类。
       */
      if(p2 instanceof Woman){
         Woman w1 = (Woman)p2;
         w1.goShopping();
         System.out.println("******Woman******");
      }
      
      if(p2 instanceof Man){
         Man m2 = (Man)p2;
         m2.earnMoney();
         System.out.println("******Man******");
      }
      
      if(p2 instanceof Person){
         System.out.println("******Person******");
      }
      if(p2 instanceof Object){
         System.out.println("******Object******");
      }
      
//    if(p2 instanceof String){
//       
//    }

练习：

     //问题一：编译时通过，运行时不通过
      //举例一：
//    Person p3 = new Woman();
//    Man m3 = (Man)p3;
      //举例二：
//    Person p4 = new Person();
//    Man m4 = (Man)p4;

   //问题二：编译通过，运行时也通过
//    Object obj = new Woman();
//    Person p = (Person)obj;

     //问题三：编译不通过
//    Man m5 = new Woman();
      
//    String str = new Date();
      
//    Object o = new Date();
//    String str1 = (String)o;

   }
}

子父类之间进行强转
a instanceof A：

判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false

使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型

如果a instanceof A返回true，则a  instanceof B也返回true
其中类B是类A的父类
if（p2 instanceof  Man）{
Man m=（Man）p2；
}

七、关键字static

某些特定数据在内存空间中只有一份，在多个对象的时候，静态的属性和方法一改变，所有的对象的对应属性和方法也改变，静态是共享的，唯一一个；非静态是各自独立的

1、static：静态的
2、static可以用来修饰：属性、方法、代码块、内部类
3、使用static修饰属性：静态变量
3.1属性：按是否使用static修饰，又分为：静态属性vs非静态属性（实例变量） 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象的非静态属性时，不会导致其他对象中同样的属性值的修改
静态变量：我们创建了类的多个对象，多个对象共享一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的
3.2static修饰属性的其他说明：
①静态变量随着类的加载而加载。可以通过“类.静态变量”的方式进行调用
②静态变量的加载要早于对象的创建
③由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中
④ 类变量 实例变量 类变量就是静态变量
类 yes no 类调用类变量：类.静态变量
对象 yes yes
3.3静态属性举例：System.out；Math.PI
4、使用static修饰方法：静态方法 ①随着类的加载而加载，可以通过“类.静态方法”的方式进行调用 ②
静态方法 非静态方法
类 yes no
对象 yes yes ③静态方法中，只能调用静态的方法和属性
非静态方法中，既可以调用非静态的方法和属性，也可以调用静态的方法和属性
5、static注意点
5.1在静态方法内，不能使用this、super关键字；因为静态方法加载在有对象之前，只能用类.xxx调用
5.2关于静态属性和静态方法的使用，大家都从生命周期的角度去理解
6、开发中，如何确定一个属性是否要声明为static的？ ---->>属性是可以被多个对象所共享的，不会随着对象的不同而不同的 ---->>类中的常量也常常声明为static
开发中，如何确定一个方法是否要声明为static的？ ---->>操作静态属性的方法，通常设置为静态的 ---->>工具类中的方法，习惯上声明为static的。比如：Math、Arrays等

7、设计模式–单例设计模式

①、所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例（只造一个对象） ②、如何实现？
饿汉式vs懒汉式 ③、区分饿汉式和懒汉式 饿汉式：
坏处：对象加载时间过长
好处：饿汉式是线程安全的

//饿汉式
public class Bank {
	
	//1、私有化类的构造器
	private Bank(){
		
	}
	//2、内部创建类的对象
	//4、要求此对象也必须声明为静态的
	private static Bank instance=new Bank();
	
	//3、提供公共的静态的方法，返回类的对象
	public static Bank getInstance(){
		return instance;
	}

}

调用的时候是类.方法

懒汉式：
好处：延迟对象的创建
坏处：目前写法，线程不安全—之后学了线程改，有判断方法，可能会让两个人都同时操作，本来只能有一个人操作

//懒汉式
public class Order {

	//1、私有化类的构造器
	private Order (){
		
	}
	//2、声明当前类对象，没有初始化
	//4、此对象也必须声明为static的
	public static Order instance=null;
	
	//3、声明public static的返回当前类对象的方法
	public static Order getInstance(){
		if(instance==null){
			instance=new Order();
		}
		return instance;
	}
}

8、main方法的使用说明

1、main（）方法作为程序的入口
2、main（）方法也是一个普通的静态方法 如果有两个main方法出现，编译时会问哪一个是程序入口
3、main（）方法可以与控制台进行交互（之前：Scanner） 传入String args【】的参数

八、关键字 final

1、final可以用来修饰的结构：类、方法、变量
2、final用来修饰一个类：此类不能被其他类所继承
3、final用来修饰方法：表明此方法不能被重写 比如：Object类中的getClass（）；
4、final用来修饰变量：此时的“变量”就称为是一个常量
4.1final修饰属性：可以考虑赋值的位置有：显示初始化、代码块、构造器
final修饰属性的话，必须赋值，在以上位置可以赋值
4.2final修饰局部变量： 尤其使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值
static final 用来修饰属性：全局常量 随着类的加载而加载 +不能变

九、abstract关键字的使用（抽象类与抽象方法）

抽象类：就是有子类和父类，继承性，因为子类继承父类，获取到父类的信息，子类的功能更加完整，以致于不需要用父类了就把父类抽象化，之后不用于造对象
在父类几何图形中，用abstract，在之后的子类中都会重写抽象方法，比较方便

1、abstract：抽象的
2、abstract可以用来修饰的结构：类、方法
3、abstract修饰类：抽象类
子类调用父类构造器，加载父类信息

此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作
abstract class Person{}
4、abstract修饰方法：抽象方法
抽象方法只有方法的声明，没有方法体（之后子类中方法被重写或者子类也是一个抽象的）
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的
若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要用abstract修饰
public abstract void Student（）；
abstract使用的注意点：
①、abstract不能用来修饰/；属性、构造器等结构
②、abstract不能用来修饰私有方法、静态方法、final的方法、final的类（因为抽象方法需要被重写，以上都不重写）
5、抽象类的匿名子类
一般来说抽象的方法是不能这样创建实例化变量的，但是如果按照以下格式在new对象之后重写方法是可以的

//创建了一匿名子类的对象：p
Person p=new Person( ){
@Override//重写父类的方法，父类就是Person
public void eat( ){
System.out.println("吃东西");
}

@Override
public void breath( ){
System.out.prinln("好好呼吸")；
}；
}
method（p）


//创建匿名子类的匿名对象
method（new Person()
{
@Override//重写父类的方法，父类就是Person
public void eat( ){
System.out.println("吃东西");
}

@Override
public void breath( ){
System.out.prinln("好好呼吸")；
}；
}
）

6、设计模式：模板方法设计模式

抽象类在此的作用就是重写抽象方法
public class TemplateTest {
	public static void main(String[] args) {
			SubTemplate t=new SubTemplate();
			t.spendTime();
	}
}
//计算代码执行的时间
abstract class Template{//父类
	public void spendTime(){
		long start=System.currentTimeMillis();
		
		code();//不确定部分
		
		long end=System.currentTimeMillis();
		
		System.out.println(end-start);
	}
	public abstract void code();
}

class SubTemplate extends Template{//子类
	@Override
	public void code(){
		//重写的方法体
	}
}

十、接口

一个类可以实现多个接口，类就可具备接口的功能

1、接口使用interface来定义 interface XXX{} 可独立定义
2、Java中，接口和类是并列的两个结构
3、如何定义接口：定义接口中的成员
3.1JDK7及以前：只能定义全局常量和抽象方法 就算没写前面的修饰限定符，但是实质上还是被限定的
>>全局常量：public static final的，但是书写时，可以省略不写
>>抽象方法：public abstract的
3.2JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
4、接口中不能定义构造器的！意味着接口不可以实例化
5、Java开发中，接口通过让类去实现（implements)的方式来使用
class Person implements xxx
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6、Java类可以实现多个接口—>弥补了Java单继承性的局限性
格式：class AA extends BB implements CC,DD,EE
7、接口与接口之间可以继承，而且可以多继承
8、接口的具体使用，体现多态性
9、接口，实际上可以看作是一种规范

10、接口的使用

接口中定义了一些抽象方法，之后被实现的时候，重写方法
10.1接口使用上也满足多态性
10.2接口，实际上就是定义了一种规范
10.3面向接口编程

多态  Use  usb=new  Flash();
public class USBTest {
	public static void main(String[] args) {
		Computer com=new Computer();
		//1、创建了接口的非匿名实现类的非匿名对象
		Flash flash=new Flash();
		com.transferData(flash);
		//2、创建了接口的非匿名实现类的匿名对象
		com.transferData(new Printer());
		//3、创建了接口的匿名实现类的非匿名对象

                                  本来不可以newUSB但是这是匿名实现类（）{重写抽象方法}即可
		USB phone=new USB(){

			@Override
			public void start() {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void stop() {
				// TODO Auto-generated method stub
				
			}
			
		};
		com.transferData(phone);
		//4、创建了接口的非匿名实现类的非匿名对象
		com.transferData(new USB(){

			@Override
			public void start() {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void stop() {
				// TODO Auto-generated method stub
				
			}
			
		});
	}
}

class Computer{
	public void transferData(USB usb){
		usb.start();
	}
	
}

interface USB{
	void start();
	
	void stop();
}

class Flash implements USB{

	@Override
	public void start() {
		System.out.println("U盘开启工作");
		
	}

	@Override
	public void stop() {
		System.out.println("U盘结束工作");
		
	}
	
}

class Printer implements USB{

	@Override
	public void start() {
		System.out.println("打印机开启工作");
		
	}

	@Override
	public void stop() {
		System.out.println("打印机结束工作");
		
	}

	
}

11、接口的应用–代理模式/工厂模式（了解） 见StaticProxyTest.java
12、JDK8新特性–静态方法和默认方法–有方法体 public static void method1（）
//接口中定义的静态方法，只能通过接口调用 接口.静态方法 //通过实现类的对象可以调用接口中的默认方法
//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法 public default void method1（）
//如果子类（实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认的是父类的同名同参的方法–>类优先原则
//如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，在实现类没有重写此方法的情况下，报错—>接口冲突
如果还想继续实现，就必须在实现类中重写此方法
–>如何实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法 //method3（）；调用自己定义的重写的方法 super.method3( );调用的是父类中声明的 调用接口中默认的方法 ComperA.super.method3（）；