Java_面向对象_下

一、接口

接口存在的两个意义：

1.用来定义规范

2.用来做功能的拓展

1.接口的成员

成员变量:只能是常量，默认修饰符：public static final

public static final int NUM = 10;  //常量名建议全部大写，初始化时必须赋值

构造方法：没有（意味着接口不能实例化）

成员方法：只能是抽象方法，默认修饰符：public abstract

public abstract void eat();

静态方法：(JDK8)

public static void house(){

}

默认方法：(JDK8)

public default void drink(){
   
};

2.接口的使用

(1)interface

接口使用interface来定义;

(2)implements

Java开发中，接口通过让类取去实现（implements）的方法来实现

• 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化；
• 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类；

(3)多个接口

Java类可以实现多个接口，弥补了Java单继承性的局限性

格式：

class A extends B implementd C,D,E{}

(4)接口与接口之间

接口与接口之间是继承，而且可以多继承

(5)JDK8中的接口知识点

知识点 1：接口中定义的静态方法，只能通过接口来调用。
知识点 2：通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
知识点 3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–>类优先原则
知识点 4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。–>接口冲突。这就需要我们必须在实现类中重写此方法

(6)举例

/*
 * 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程！
 * 
 */
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. 创建了接口的匿名实现类的非匿名对象
		USB phone = new USB(){

			@Override
			public void start() {
				System.out.println("手机开始工作");
			}

			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
			
		};
		com.transferData(phone);
		//4. 创建了接口的匿名实现类的匿名对象
		com.transferData(new USB(){
			@Override
			public void start() {
				System.out.println("mp3 开始工作");
			}

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

class Computer{
	
	public void transferData(USB usb){//USB usb = new Flash();
		usb.start();
		
		System.out.println("具体传输数据的细节");
		
		usb.stop();
	}
	
}
//定义接口
interface USB{
	//常量:定义了长、宽
	void start();//省略了public abstract
	
	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("打印机结束工作");
	}
	
}

二、关键字

1.this

this可以用来修饰：属性、方法、构造器

使用：

1.当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。（this是当前对象自己）

2.this调用构造器

• 在类的构造器中，可以显示的使用“this(形参列表)“方式，调用本类中指定的其他构造器；
• 构造器不能通过”this(形参列表)”的方式调用自己；
• 如果一个类中有n个构造器，则最多有n - 1个构造器使用“this(形参列表)”的方式；
• 规定：“this(形参列表)”必须声明在当前构造器的首行；
• 构造器内部，最多只能声明一个“this(形参列表)",用来调用其他的构造器；

2.package

为了更好的实现项目中类的管理，提供包的概念。

使用：

• 使用package声明类或接口所属的包，声明在源文件的首行；
• 包，属于标识符，遵循标识符的命名规则、规范、见名知义；
• 每“ . ”一次，就代表一层文件目录。

补充：

• 同一个包下，不能命名同名的接口、类；
• 不同的包下，可以命名同名的接口、类；

拓展：JKD中主要的包介绍

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

3.import

为使用定义在不同包中的Java类，需要import语句来引入指定包层次下所需的类或者全部类。即import语句告诉编译器到哪里去寻找类。

(1)语法格式

import 包名.类名；

(2)注意

• 在源文件中使用import显示导入指定包下的类或接口；
• 声明在包的声明和类的声明之间；
• 如果需要导入多个结构，则并列写出多个import语句即可；
• 可以使用“XXX.”的方式，表示可以导入XXX包下的所有结构*；但是如果使用的是XXX子包下的结构，则任需要显示导入次子包；
• 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略次import语句；
• 如果在代码中使用不同包下的同名的类。那么就至少需要一个类使用类的全命名的方式指明调用的是哪个类；
• import static：导入指定类或接口中的静态结构：属性或方法；

(3)应用举例

import pack1.pack2.Test;
public class PackTest{
    public static void main(String args[]){
        Test t = new Test();
        t.display();
    }
}

import pack1.pack2.*;	//表示引入pack1.pack2包中的所有结构

//全类名方式
com.atguigu.exer3.Account acc = new com.atguigu.exer3.Account();	//com.atguigu.exer3包名 Account类名

4.super

super理解为：父类的

super可以用来调用：属性、方法、构造器

super的使用：

(1)我们可以在子类的方法或构造器中，通过使用”super.属性”或“super.方法“的方式，显示的调用父类中声明的属性或方法，但通常的情况下，我们习惯省略”supper. ";

(2)特殊情况：当子类和父类中定义了同名的属性时，我们想要在子类中调用父类中声明的属性，则必须显示的使用“super.属性”的方式，表明调用的是父类中声明的属性；

(3)特殊情况：当子类重写了父类中的方法后，我们想在子类的方法中调用父类中被重写的方法时，则必须显示的使用“super.方法”的方式，表明调用的是父类中被重写的方法；

super调用构造器：

(1)我们可以在子类的构造器中显示的使用“super(形参列表)”的方式，调用父类中声明的指定的构造器；

(2)“super(形参列表)”的使用，必须声明在子类构造器的首行！

(3)我们在类的构造器中，针对于“this(形参列表)"或”super(形参列表)“只能二选一，不能同时出现；

(4)在构造器的首行，没有显示的声明”this(形参列表)“或”super(形参列表)“，则默认调用的是父类中空参的构造器；

(5)在类的多个构造器中，至少有一个类的构造器中使用了”super(形参列表)”，调用父类中的构造器；

5.instanceof

X instanceof A :检验X是否为类A的对象，返回值为boolean型

注意：

• 要求X所属的类与类A必须是子类和父类的关系，否则编译错误；
• 如果X属于类A的子类，X instanceof A 的值也为ture；
• 如果 a instanceof A返回ture，则a instanceof B也返回true;其中，类B是类A的父类。

使用情景：

为了避免在向下转型是出现ClassCastExecption的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回ture，就进行向下转型，如果返回false，不进行向下转型。

6.static

static:静态的

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

(1)修饰属性

属性按是否使用static修饰，分为：静态属性和非静态属性（实例属性）

静态属性：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，时修改过了的；

实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的改变；

说明：

• 静态变量随着类的加载而加载。可以通过“类.静态变量”的方法进行调用；
• 静态变量的加载要早于对象的创建；
• 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中；

(2)修饰方法

修饰方法：静态方法

• 随着类的加载而加载，可以通过“类.静态方法“的方式调用；
• 静态方法中，只能调用静态的方法或属性；非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性；

(3)注意

• 在静态的方法内，不能使用this关键字、super关键字
• 关于静态属性和方法的使用，可以从生命周期的角度取理解（想创建静态方法或调用静态属性，再创造对象）

(4)单例设计模式

所谓单例设计模式就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

如果我们要让类在一个虚拟机中只产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类的内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

如何实现？：懒汉式或饿汉式

饿汉式：对象加载时间长（坏处），线程安全（好处）

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

懒汉式：延迟对象的创建（好处），线程不安全（坏处）

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

7.final

final可以用来修饰类的结构：类、方法、变量

修饰类

此类不能被其他类所继承。如：String类、System类、StringBuffer类等。

修饰方法

表明此方法不能被重写。如：Object类中getClass()。

修饰变量

此时的”变量“就称为是一个常量

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

public class FinalTest{
    //显示初始化
    final int WIDTH = 0;
    final int LEFT;
    final int RIGHT;
    //代码块中初始化
    {
        LEFT = 1;
    }
    //构造器中初始化
    public FinalTest(){
        RIGHT = 2;
    }
    
    public FinalTest(int n){
        RIGHT = n;
    }
}

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

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

三、权限修饰符

Java规定了4种权限修饰符（权限从小到大排列）：private、缺省、protected、public

4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	Yes
（缺省）	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

注：

• public类可以在任意地方被访问；
• 对于类(class)的权限修饰只可以用public和缺省；

拓展：UML类图

四、内部类

偷个懒，这位博主写得很详细

链接