java笔记-构造代码块和static案例，接口interface

最新推荐文章于 2023-08-11 15:40:39 发布

DreamZroom

最新推荐文章于 2023-08-11 15:40:39 发布

阅读量231

点赞数

文章标签： java

本文链接：https://blog.csdn.net/DreamZroom/article/details/105983415

版权

1.构造代码快和static案例

计算器
	巨鹿用户的登录次数，当前网站的访问人数...
	
自动生成用户id号
	会员id号不可以重复，而且是用户在申请账号时自动生成！！！
	
分析：
	1.程序不退出，id号始终处于一种记录状态，保存下一个用户的id号
	2.用户提供不管多少数据，都要给予一个对应的id号
	
解决：
	id号始终处于一种记录状态
	1.这里需要一个变量来保存id号
		int类型
		局部变量：
		局部变量在烦恼高发内，方法运行结束，局部变量销毁，无法作为持久化保存。【不能使用】
			
		成员变量：
		成员变量是保存在每一个对象中，而且每一个对象中保存的数据是不一样的，而且需要操作来进行获取，对象是存在可能性在一定条件下被销毁的。不具有持久性，操作较为繁琐
			
		静态成员变量：
		整个代码运行周期内始终存在，并且和对象无关，不会收到对象的影响。可以直接通过类名操作，该变量保存在内存数据区，是一个共享资源。
	
	2.用户提供不管多少数据，都要给于一个对应的ID号
		用户使用不同的构造方法，都要能够有赋值对应ID号，ID号不是用户提供的！！！
		构造代码块不管你调用哪一个new + 构造方法，都要执行对应的操作！！

1.2代码实现

package com.qfedu.a_count;

/**
* 不管用户采用哪一种方式来创建对象，都会有一个唯一的ID号赋
值操作
* @author Anonymous
*
*/
public class Vip {
private int id;
private String name;
private int age;
private String address;

/**
* 使用静态成员变量count来计数ID
*/
private static int count = 1;

/*
* 构造代码块完成ID赋值操作，使用静态成员变量count来进
行赋值
* 并且每一次操作完成之后，count += 1
*/
{
	id = count;
	count += 1;
}

public Vip() {}

public Vip(String name) {
	this.name = name;
}
public Vip(String name, int age) {
	this.name = name;
	this.age = age;
}
public Vip(String name, int age, String address) {
	this.name = name;
	this.age = age;
	this.address = address;
}

public int getId() {
	return id;
}

public void setId(int id) {
	this.id = id;
}

public String getName() {
	return name;
}

public void setName(String name) {
	this.name = name;
}

public int getAge() {
	return age;
}

public void setAge(int age) {
	this.age = age;
}

public String getAddress() {
	return address;
}
public void setAddress(String address) {
	this.address = address;
}
@Override

public String toString() {
	return "Vip [id=" + id + ", name=" + name
			+ ", age=" + age + ", address=" + address + "]";
	}
}

2.接口

2.1生活中的接口

生活常见接口：
	USB Type-C雷电 RJ45 HDMI VPA PCI-E Lighting 3.5MM M.2 SATA
	
接口有什么作用
	拓展功能，连接外部设备
	
USB接口限制了什么？
	制定规范，制定协议
	符合USB接口规范，USB接口协议才可以连接
	
RJ45 网络接口！！！

2.2Java中定义接口的格式

关键字：
	interface
	UI	Design	
	
格式：
	interface 接口名 {
		成员变量
		成员方法
	}
	
要求：
	1.接口名要求符合命名规范，大驼峰命名法，见名知意
	2. 成员变量【缺省属性】 public static final 定义时
必须初始化
	3. 成员方法【缺省属性】 public abstract 方法没有方法
体

package com.qfedu.b_interface;
	/**
	* 自定义接口，接口名A
	*
	* 两个问题:
	* 1. USB接口，尺寸固定之后，有人改吗？
	* 没有人修改
	* 2. USB接口做什么，是接口决定?还是设备决定?
	* 设备
	* 思考:
	* 静态?
	* abstract?
	* final?
	* 继承?
	* @author Anonymous
	*
	*/
interface A {
	/* 成员变量
	* The blank final field num may not have been
	initialized
	*
	* 通过Outline工具，发现当前成员变量存在public
	static final修饰，但是代码并没有
	* 显式当前修饰内容
	* 【缺省属性】 public static final
	*/
	int num = 10;
	/*
	* 成员方法
	* Abstract methods do not specify a body
	*
	* 错误提示，当前代码中test方法是一个abstract修饰方
	法，并且在Outline发现方法
	* 存在一个A标记，证明为abstract，但是代码中并没有显
	式展示abstract修饰
	* 【缺省属性】public abstract
	*/
	void test();
}

public class Demo1 {
	
}

2.3 Java中类【遵从】接口的格式

关键字:
	implements
格式:
	class A implements B {
        
	}
	A类是B接口的实现类
	A类遵从B接口

/**
* B类通过关键字 implements 遵从接口A，要求是实现接口A中
的所有
* 缺省属性为public abstract修饰的方法。
* @author Anonymous
*
*/
class B implements A {

    @Override
	public void test() {
		System.out.println("B类遵从接口A，实现test方法");
	}
}

2.4一个类可以同时遵从多个接口

USB接口可以同时兼容多个协议
	USB3.1 USB3.0 USB2.0 USB1.0

package com.qfedu.b_interface;

	interface C {
		void testC();
	}
	
	interface D {
		void testD();
	}
	
	interface E {
		void testE();
	}
	/**
	* 一个类可以同时遵从多个接口
	* 在implements关键字之后，接口使用 , 分割
	* @author Anonymous
	*
	*/
class F implements C, D, E {
	@Override
	public void testE() {
		System.out.println("遵从接口E，实现testE方法");
	}
		@Override
	public void testD() {
		System.out.println("遵从接口D，实现testD方法");
	}
	@Override
	public void testC() {
		System.out.println("遵从接口C，实现testC方法");
	}
}
	
public class Demo2 {

}

2.5 接口可以继承接口

关键字:
	extends

package com.qfedu.b_interface;

/*
* USB1.0协议
*/
interface Usb1_0 {
	void usb1_0();
}

	/*
	* USB2.0协议
	*/
interface Usb2_0 {
	void usb2_0();
}

	/*
	* USB3.0协议
	*/
interface Usb3_0 {
	void usb3_0();
}
/**
* 小米电脑上的USB接口需要兼容USB1.0 USB2.0 USB3.0 协议
* 接口可以使用extends完成继承，并且允许多继承存在
* @author Anonymous
*
*/
interface UsbMi extends Usb1_0, Usb2_0, Usb3_0 {
	void usbMi();
}
class MiGameComputer implements UsbMi {
	@Override
	public void usb1_0() {
		System.out.println("兼容USB1.0");
	}	
	@Override
	public void usb2_0() {
		System.out.println("兼容USB2.0");
	}
	@Override
	public void usb3_0() {
		System.out.println("兼容USB3.0");
	}
	@Override
	public void usbMi() {
		System.out.println("小米USB接口");
	}
}
public class Demo3 {
	public static void main(String[] args) {
		new MiGameComputer().usb1_0();
		new MiGameComputer().usb2_0();
		new MiGameComputer().usb3_0();
		new MiGameComputer().usbMi();
	}
}

2.6abstract类遵从接口

abstract修饰的方法
	1.没有方法体
	2.必须定义在abstract修饰的类内，或者interface接口内
	
一个abstract修饰的类遵从接口，相对于非abstract修饰的类有什么区别？？？
	abstract遵从接口不强制实现任何方法！！！

package com.qfedu.b_interface;

interface Servlet {
	/**
	* init初始化方法
	*/
	void init();
	/**
	* 提供服务的核心方法
	*/
	void service();
}

/**
* abstract修饰的类遵从接口，不强制完成接口中缺省属性为
abstract修饰的方法
* 一般会选择性完成一些统一功能方法，简化后期代码的压力
* @author Anonymous
*
*/

abstract class BaseServlet implements Servlet {
	
	/*
	* 利用abstract统一实现init方法，简化提供真实服务功能
	类内代码
	* 结构
	*/
	@Override
	public void init() {
		System.out.println("BaseServlet实现init方法");
	}
}
class MyServlet extends BaseServlet {
	
	/*
	* 提供服务的类只需要完成service核心方法即可
	* init初始化方式有abstract class BaseServlet提供
	*/
	@Override
	public void service() {
		System.out.println("MyServlet实现service方法");
	}
}
class MyServlet2 extends BaseServlet {
	@Override
	public void service() {
		System.out.println("MyServlet2实现service方法");
	}
}
public class Demo4 {
	public static void main(String[] args) {
		new MyServlet().init();
		new MyServlet().service();
		System.out.println("--------------------");
		new MyServlet2().init();
		new MyServlet2().service();
	}
}

2.7 JDK1.8新特征 default关键字

JDK1.8 更新特征
	default关键字可以在接口中使用，用于修饰方法，使用
default关键字修饰的方法在接口中是允许有方法体
	【默认方法】【非强制重写方法】

kage com.qfedu.b_interface;

interface DefaultInterface {
	// 【缺省属性】public abstract
	void test();
	
	default public void testDefault() {
		System.out.println("testDefault() 默认方法，非强制重写方法");
	}

	default public void defaultMethod() {
		System.out.println("defaultMethod() 默认方法，非强制重写方法");
	}
}
class Demo implements DefaultInterface {

	/*
	* 只强制完成【缺省属性】public abstract修饰的方法
	test
	*/	
	@Override
	public void test() {
		System.out.println("强制实现的test方法");
	}
	@Override
	public void testDefault() {
		System.out.println("实现类重写default方法");
	}
}
public class Demo5 {
	public static void main(String[] args) {
		new Demo().test();
		new Demo().testDefault();
		new Demo().defaultMethod();
	}
}

3.多态【重点】

3.1 动物之间的关系

动物能不能看作是一个类？
	Animal
动物园:
	老虎 是不是动物??? 是
	熊猫 是不是动物??? 是
	猴子 是不是动物??? 是
class Animal {

}

老虎，熊猫，猴子，能不能继承Animal类

package com.qfedu.c;

/**
* 动物类
* @author Anonymous
*
*/

class Animal {
	
}

/**
* 老虎类，继承Animal类
* @author Anonymous
*
*/

class Tiger extends Animal {
	
}

/**
* 熊猫类，继承Animal类
* @author Anonymous
*
*/
class Panda extends Animal {
	
}

/**
* 猴子类，继承Animal类
* @author Anonymous
*
*/
class Monkey extends Animal {
	
}

public class Demo1 {
	public static void main(String[] args) {
		Animal animal = new Animal();
		Tiger tiger = new Tiger();
		Panda panda = new Panda();
		Monkey monkey = new Monkey();
		
		showAnimal(animal);
		// tiger也是动物
		showAnimal(tiger);
		// panda也是动物
		showAnimal(panda);
		// monkey还是动物
		showAnimal(monkey);
		System.out.println("--------------------------------");
		
		// 引用数据类型强制类型转换，讲Animal类型强制转为Panda
		Panda p = (Panda) getAnimal();
		System.out.println(p);
	}
	
	/**
	* 展示动物的方法
	*
	* @param animal 这里需要的是一个Animal类对象
	*/
	public static void showAnimal(Animal animal) {
		System.out.println(animal);
	}
	/**
	* 返回一个动物类对象
	*
	* @return Animal类对象
	*/
	public static Animal getAnimal() {
		return new Panda(); //Panda类对象是动物
		// return new Tiger(); //Tiger类对象是动物
		// return new Monkey(); //Monkey类对象是动物
		// return new Animal();
	}
}

3.2 小总结

1. 一个方法需要的参数是父类，传入实际参数是父类对象本身，或
者其子类对象都是OK的！
2. 一个方法返回值类型是父类，实际返回的数据时父类对象本身，
或者其子类对象也是OK的！
3. 引用数据类型之间的强制类型转换时允许使用，但是要求明确真
实数据类型是一致的，不然会导致异常出现ClassCastException

3.3 USB接口和USB设备

USB接口
	规定一个方法
		connect方法
键盘一个类
鼠标一个类

package com.qfedu.c;

/**
* USB接口
*
* @author Anonymous
*
*/
interface USB {
	
	/**
	* 要求所有的USB设备，都要完成connect方法
	* 告知PC当前设备是什么功能
	*/
	void connect();
}

/**
* Mouse类遵从USB接口，可以认为是一个USB设备
*
* @author Anonymous
*
*/
class Mouse implements USB {
	
	@Override
	public void connect() {
		System.out.println("鼠标控制光标");
	}
}

/**
* Logi是Mouse类的子类，是鼠标类的子类，
* 是否间接遵从USB接口? 是的
*
* 算不算USB设备? 算
* @author Anonymous
*
*/
class Logi extends Mouse {
	@Override
	public void connect() {
		System.out.println("Logi Master 2S");
	}
}

/**
* Keyboard类遵从USB接口，也可以认为是一个USB设备
*
* @author Anonymous
*
*/
class Keyboard implements USB {
	@Override
	public void connect() {
		System.out.println("键盘敲代码");
	}
}

/**
* IKBC类，继承Keyboard类，是键盘类的子类
* 算不算USB设备??? 算
* @author Anonymous
*
*/
class IKBC extends Keyboard {
	@Override
	public void connect() {
		System.out.println("IKBC C87 270 -/+RMB");
	}
}

/**
* 电脑类
*
* @author Anonymous
*
*/
class Computer {
	/**
	* 电脑使用通过USB接口，连接USB设备
	* @param usb USB接口，要求连接是一个USB设备
	*/
	public void useUSBInterface(USB usb) {
		// 通过USB设备执行connect方法，执行功能
		usb.connect();
	}
}
public class Demo2 {
	public static void main(String[] args) {

		// 电脑类对象
		Computer computer = new Computer();
		// Mouse是USB设备
		Mouse mouse = new Mouse();
		// Keyboard也是USB设备
		Keyboard keyboard = new Keyboard();
		// 电脑需要通过USB接口连接USB设备
		computer.useUSBInterface(mouse);
		computer.useUSBInterface(keyboard);
		// computer通过USB设备连接Mouse或者Keyboard类的子类是完全OK的
		// 因为这些子类也是USB设备
		computer.useUSBInterface(new Logi());
		computer.useUSBInterface(new IKBC());
	}	
}

3.4小总结

1. 一个方法需要的参数是USB接口，但是传入的对象是USB接口的直接实现类或者间接实现类都是完全OK
2. 代码整个过程中是完全符合生活逻辑的！！！

3.5 这其实是多态

1. 父类的引用指向子类的对象
2. 或者接口的引用指向遵从接口的类对象
这就是多态

DreamZroom

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java笔记-构造代码块和static案例，接口interface

1.构造代码快和static案例计算器巨鹿用户的登录次数，当前网站的访问人数... 自动生成用户id号会员id号不可以重复，而且是用户在申请账号时自动生成！！！分析： 1.程序不退出，id号始终处于一种记录状态，保存下一个用户的id号 2.用户提供不管多少数据，都要给予一个对应的id号解决： id号始终处于一种记录状态 1.这里需要一个变量来保存id号 int...
复制链接

扫一扫