山丘i资料

本文主要介绍山丘i资料 方法和在新技术下所面对的“挑战”,方便大家深入理解山丘i资料 过程。本文也将分享山丘i资料 所遇到的问题和应对策略,怎么解决怎么做的问题。
通过深入本文可以理解代码原理,进行代码文档的下载,也可以查看相应 Demo 部署效果。

一、 static

  1. static:静态的,可以用来修饰属性、方法、代码块(或初始化块)、内部类
  2. static修饰属性(类变量):
    • 由类创建的所有的对象,都共用这一个属性
    • 当其中一个对象对此属性进行修改,会导致其他对象对此属性的一个调用。vs 实例变量(非static修饰的属性,各个对象各自拥有一套副本)
    • 类变量随着类的加载而加载的,而且独一份
    • 静态的变量可以直接通过“类.类变量”的形式来调用
    • 类变量的加载是要早于对象。所以当有对象以后,可以“对象.类变量”使用。但是"类.实例变量"是不行的。
    • 类变量存在于静态域中。
  3. static修饰方法(类方法):
    • 随着类的加载而加载,在内存中也是独一份
    • 可以直接通过“类.类方法”的方式调用
    • 内部可以调用静态的属性或静态的方法,而不能调用非静态的属性或方法。反之,非静态的方法是可以调用静态的属性或静态的方法
    • 静态的方法内是不可以有this或super关键字的!
    • 静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构,同时被回收也要晚于非静态的结构
  4. 开发中,如何确定一个属性是否要有声明为static的?
    • 属性可以被多个对象共享的,不会随着对象的不同而不同
  5. 开发中,如何确定一个方法是否要有声明为static的?
    • 操作静态属性的方法通常也是静态的
    • 工具类中对 方法通常也为static的
public class TestCircle { 	public static void main(String[] args) { 		Circle c1 = new Circle(); 		Circle c2 = new Circle(2.3); 		System.out.println(c1); 		System.out.println(c2); 		System.out.println(Circle.getTotal()); 	} }   class Circle{ 	private double radius; 	private static String info = "我是一个圆"; 	private int id;//编号 	private static int init = 1001;//控制每个对象的id 	private static int total = 0;//记录创建了多少个对象 	 	public Circle(){ 		this.id = init++; 		total++; 	} 	public Circle(double radius){ 		this.radius = radius; 		this.id = init++; 		total++; 	} 	 	 	 	public double getRadius() { 		return radius; 	} 	public void setRadius(double radius) { 		this.radius = radius; 	} 	public static String getInfo() { 		return info; 	} 	public static void setInfo(String info) { 		Circle.info = info; 	} 	public int getId() { 		return id; 	} 	public void setId(int id) { 		this.id = id; 	} 	public static int getTotal() { 		return total; 	} 	public static void setTotal(int total) { 		Circle.total = total; 	} 	@Override 	public String toString() { 		return "Circle [radius=" + radius + ", id=" + id + "]"; 	} 	public static void show(){ 		System.out.println(Circle.info); 	} 	 	public void desc(){ 		System.out.println(this.info); 	}  } 

二、单例设计模式

解决的问题:如何只让设计的类只能创建一个对象
如何实现:饿汉式 & 懒汉式

1. 饿汉式1

class Bank{ 	//1.私有化构造器 	private Bank(){} 	//2.创建类的对象,同时设置为private的,通过公共的来调用,体现封装性 	//4.要求此对象也为static的 	private static Bank instance = new Bank(); 	//3.此公共的方法,必须为static  	public static Bank getInstance(){ 		return instance;	 	} } 

2. 饿汉式2

class Bank{ 	//1.私有化构造器 	private Bank(){} 	//2.创建类的对象,同时设置为private的,通过公共的来调用,体现封装性 	//4.要求此对象也为static的 	private static Bank instance = null; 	static{ 		instance  = new Bank();	 	} 	//3.此公共的方法,必须为static   	public static Bank getInstance(){ 		return instance;	 	} } 

3. 懒汉式

class Bank{ 	private Bank(){} 	 	private static Bank instance = null; 	 	public static Bank getInstance(){ 		if(instance == null){//可能存在线程安全问题的! 			instance = new Bank();		 		}	 		return instance; 	} } 

山丘i

三、main()方法

public static void main(String[] args){      //方法体      }  //1.main()是一个方法,是主方法,为程序的入口 //2.权限修饰符:public protected 缺省 private ---面向对象的封装性 //3.对于方法来讲:static final abstract  //4.方法的返回值:void /  具体的返回值类型(基本的数据类型 & 引用数据类型),方法内部一定要有return //5.方法名:命名的规则:xxxYyyZzz。给方法命名时,要见名之意 //6.形参列表:同一个方法名不同的形参列表的诸多个方法间构成重载。   形参 & 实参---方法的参数传递机制:值传递 //7.方法体:方法定义的是一种功能,具体的实现由方法体操作。 

四、代码块

  1. 代码块:是类的第4个成员 { }
    作用:用来初始化类的属性
    分类:只能用static来修饰。
  2. 静态代码块:
    • 里面可以有输出语句
    • 随着类的加载而加载并且执行,而且只被加载一次
    • 多个静态代码块之间按照顺序结构执行
    • 静态代码块的执行要早于非静态代码块的执行。
    • 静态的代码块中只能执行静态的结构(类属性,类方法)
  3. 非静态代码块:
    • 可以对类的属性(静态的 & 非静态的)进行初始化操作,同时也可以调用本类声明的方法(静态的 & 非静态的)
    • 里面可以有输出语句
    • 一个类中可以有多个非静态的代码块,多个代码块之间按照顺序结构执行
    • 每创建一个类的对象,非静态代码块就加载一次。
    • 非静态代码块的执行要早于构造器
  4. 关于属性赋值的操作:
    • 默认的初始化
    • 显式的初始化或代码块初始化(此处两个结构按照顺序执行)
    • 构造器中;
    • 以上是对象的属性初始化的过程——
    • 通过方法对对象的相应属性进行修改

1. 常见问题

总结:由父及子,静态先行

class Root{ 	static{ 		System.out.println("Root的静态初始化块"); 	} 	{ 		System.out.println("Root的普通初始化块"); 	} 	public Root(){ 		super(); 		System.out.println("Root的无参数的构造器"); 	} } class Mid extends Root{ 	static{ 		System.out.println("Mid的静态初始化块"); 	} 	{ 		System.out.println("Mid的普通初始化块"); 	} 	public Mid(){ 		super(); 		System.out.println("Mid的无参数的构造器"); 	} 	public Mid(String msg){ 		//通过this调用同一类中重载的构造器 		this(); 		System.out.println("Mid的带参数构造器,其参数值:" 			+ msg); 	} } class Leaf extends Mid{ 	static{ 		System.out.println("Leaf的静态初始化块"); 	} 	{ 		System.out.println("Leaf的普通初始化块"); 	}	 	public Leaf(){ 		//通过super调用父类中有一个字符串参数的构造器 		super("尚硅谷"); 		System.out.println("Leaf的构造器"); 	} } public class LeafTest{ 	public static void main(String[] args){ 		new Leaf();  		System.out.println(); 		new Leaf(); 	} }   
package com.atguigu.java3;  class Father { 	static { 		System.out.println("11111111111"); 	} 	{ 		System.out.println("22222222222"); 	}  	public Father() { 		System.out.println("33333333333");  	}  }  public class Son extends Father { 	static { 		System.out.println("44444444444"); 	} 	{ 		System.out.println("55555555555"); 	} 	public Son() { 		System.out.println("66666666666"); 	}   	public static void main(String[] args) { // 由父及子 静态先行 		System.out.println("77777777777"); 		System.out.println("************************"); 		new Son(); 		System.out.println("************************"); 		new Son(); 		System.out.println("************************"); 		new Father(); 	}  }  

五、final关键词

final:最终的 ,可以用来修饰类、属性、方法

  1. final修饰类:这个类就不能被继承。如:String类、StringBuffer类、System类
  2. final修饰方法:不能被重写。如:Object类的getClass()
  3. final修饰属性:此属性就是一个常量,一旦初始化后,不可再被赋值。习惯上,常量用大写字符表示
    此常量在哪里赋值:①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。
  4. 变量用static final修饰:全局常量。比如:Math 类的PI
class D{ 	final int I = 12; 	final double PI; 	final String NAME;  	public void m1(){ 		System.out.println(I); //		I = 10;  	} 	{ 		PI = 3.14; 	} 	 	public D(){ 		NAME = "DD"; 	} 	public D(String name){ 		this(); 		//NAME = name; 	} } 

山丘i

六、抽象 abstract

abstract:抽象的,用来修饰类、方法

  1. abstract修饰类:抽象类
    • 不可被实例化
    • 抽象类有构造器 (凡是类都有构造器),便于子类实例化时调用
    • 抽象方法所在的类,一定是抽象类
    • 抽象类中可以没有抽象方法。
    • 当我们设计一个类,不需要创建此类的实例时候,就可以考虑将其设置为抽象的,由其子类实现这个类的抽象方法以后,就行实例化
  2. abstract修饰方法:抽象方法
    • 格式:没有方法体,包括{}.如:public abstract void eat();
    • 抽象方法只保留方法的功能,而具体的执行,交给继承抽象类的子类,由子类重写此抽象方法
    • 若子类继承抽象类,没有重写所有的抽象方法,意味着此类中仍有抽象方法,则此类必须声明为抽象的

1. 模板方法设计模式

//模板方法设计模式 public class TestTemplate { 	public static void main(String[] args) { 		new SubTemplate().spendTime(); 	} }  abstract class Template {  	public abstract void code();  	public void spendTime() { 		long start = System.currentTimeMillis();  		this.code();  		long end = System.currentTimeMillis(); 		System.out.println("花费的时间为:" + (end - start)); 	} }  class SubTemplate extends Template { 	 	public void code() { 		boolean flag = false; 		for(int i = 2;i <= 10000;i++){ 			for(int j = 2;j <= Math.sqrt(i);j++){ 				if(i % j == 0){ 					flag = true; 					break; 				}  			} 			if(!flag){ 				System.out.println(i); 			} 			flag = false; 		} 	} }  

2. 抽象类的应用

//抽象类的应用:模板方法的设计模式 public class TemplateMethodTest {  	public static void main(String[] args) { 		BankTemplateMethod btm = new DrawMoney(); 		btm.process();  		BankTemplateMethod btm2 = new ManageMoney(); 		btm2.process(); 	} } abstract class BankTemplateMethod { 	// 具体方法 	public void takeNumber() { 		System.out.println("取号排队"); 	}  	public abstract void transact(); // 办理具体的业务 //钩子方法  	public void evaluate() { 		System.out.println("反馈评分"); 	}  	// 模板方法,把基本操作组合到一起,子类一般不能重写 	public final void process() { 		this.takeNumber();  		this.transact();// 像个钩子,具体执行时,挂哪个子类,就执行哪个子类的实现代码  		this.evaluate(); 	} }  class DrawMoney extends BankTemplateMethod { 	public void transact() { 		System.out.println("我要取款!!!"); 	} }  class ManageMoney extends BankTemplateMethod { 	public void transact() { 		System.out.println("我要理财!我这里有2000万美元!!"); 	} }  

七、接口 interface

接口(interface) 是与类并行的一个概念

  1. 接口可以看做是一个特殊的抽象类是常量(public static final 可以省略)与抽象方法的一个集合,不能包含变量、一般的方法。
  2. 接口是没有构造器的
  3. 接口定义的就是一种功能。此功能可以被类所实现(implements)
    比如:class CC extends DD implements AA
  4. 实现接口的类,必须要重写其中的所有的抽象方法,方可实例化。若没有重写所有的抽象方法,则此类仍为一个抽象类
  5. 类可以实现多个接口。—-java 中的类的继承是单继承的
  6. 接口与接口之间也是继承的关系,而且可以实现多继承

5,6描述的是java中的继承的特点。

  1. 接口与具体的实现类之间也存在多态性

1. 接口的使用

  • 接口使用上也满足多态性
  • 接口,实际上就是定义了一种规范
  • 面向接口编程
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(); 	 	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("打印机结束工作"); 	} 	 }   

2. 工厂方法的设计模板

//接口的应用:工厂方法的设计模式 public class TestFactoryMethod { 	public static void main(String[] args) { 		IWorkFactory i = new StudentWorkFactory(); 		i.getWork().doWork(); 		 		IWorkFactory i1 = new TeacherWorkFactory(); 		i1.getWork().doWork(); 	} }  interface IWorkFactory{ 	Work getWork(); } class StudentWorkFactory implements IWorkFactory{  	@Override 	public Work getWork() { 		return new StudentWork(); 	} 	 } class TeacherWorkFactory implements IWorkFactory{  	@Override 	public Work getWork() { 		return new TeacherWork(); 	} 	 }  interface Work{ 	void doWork(); }  class StudentWork implements Work{  	@Override 	public void doWork() { 		System.out.println("学生写作业"); 	} 	 } class TeacherWork implements Work{  	@Override 	public void doWork() { 		System.out.println("老师批改作业"); 	} }  

3. 代理模式

//接口的应用:代理模式(静态代理) public class TestProxy { 	public static void main(String[] args) { 		Object obj = new ProxyObject(); 		obj.action(); 	} }  interface Object{ 	void action(); } //代理类 class ProxyObject implements Object{ 	Object obj; 	 	public ProxyObject(){ 		System.out.println("代理类创建成功"); 		obj = new ObjctImpl(); 	} 	 	public void action(){ 		System.out.println("代理类开始执行"); 		obj.action(); 		System.out.println("代理类执行结束"); 	} } //被代理类 class ObjctImpl implements Object{  	@Override 	public void action() { 		System.out.println("=====被代理类开始执行======"); 		System.out.println("=====具体的操作======"); 		System.out.println("=====被代理类执行完毕======"); 		 	} 	 } 

4. 问题

山丘i

interface A { 	int x = 0; }  class B { 	int x = 1; }  class C extends B implements A { 	public void pX() { 		//编译不通过。因为x是不明确的 		// System.out.println(x); 		System.out.println(super.x);//1 		System.out.println(A.x);//0 	}  	public static void main(String[] args) { 		new C().pX(); 	} }  

山丘i

5. Java8新特性

山丘i

山丘i

八、内部类

Java中允许将一类A声明在类B中,则类A就是内部类

1. 成员内部类(静态、非静态)

  • 作为一个类
    • 类内可以定义属性、方法、构造器
    • 可以被final修饰,表示此类不能继承,也就是不适用final,就可以被继承
    • 可以被abstract修饰
  • 作为外部类的
    • 调用外部类的结构
    • 可以被static修饰
    • 可以被4种不同的权限修饰

局部内部类(方法内、代码块、构造器中)

public class InnerClassTest { 	public static void main(String[] args) { 		 		//创建Dog实例(静态的成员内部类): 		Person.Dog dog = new Person.Dog(); 		dog.show(); 		//创建Bird实例(非静态的成员内部类): //		Person.Bird bird = new Person.Bird();//错误的 		Person p = new Person(); 		Person.Bird bird = p.new Bird(); 		bird.sing(); 		 		System.out.println(); 		 		bird.display("黄鹂"); 		 	} }   class Person{ 	 	String name = "小明"; 	int age; 	 	public void eat(){ 		System.out.println("人:吃饭"); 	} 	 	 	//静态成员内部类 	static class Dog{ 		String name; 		int age; 		 		public void show(){ 			System.out.println("卡拉是条狗"); //			eat(); 		} 		 	} 	//非静态成员内部类 	class Bird{ 		String name = "杜鹃"; 		 		public Bird(){ 			 		} 		 		public void sing(){ 			System.out.println("我是一只小小鸟"); 			Person.this.eat();//调用外部类的非静态属性 			eat(); 			System.out.println(age); 		} 		 		public void display(String name){ 			System.out.println(name);//方法的形参 			System.out.println(this.name);//内部类的属性 			System.out.println(Person.this.name);//外部类的属性 		} 	} 	 	 	public void method(){ 		//局部内部类 		class AA{ 			 		} 	} 	 	{ 		//局部内部类 		class BB{ 			 		} 	} 	 	public Person(){ 		//局部内部类 		class CC{ 			 		} 	} 	 } 

2. 注意

package com.atguigu.java;  public class InnerClassTest { 	/* 	 * 在局部内部类声明的方法中(比如:show)如果调用局部内部类所声明的方法(比如:method)中的局部变量(比如:num)的话, 	 * 要求此局部变量声明为final的。 	 *  	 * jdk 7及之前版本:要求此局部变量显式的声明为final的 	 * jdk 8及之后的版本:可以省略final的声明 	 *  	 */ 	public void method(){ 		//局部变量 		int num = 10; 		 		class AA{	 			public void show(){ //				num = 20; 				System.out.println(num); 				 			}	 		}	 	} } 

山丘i资料部分资料来自网络,侵权毕设源码联系删除

区块链毕设网(www.qklbishe.com)全网最靠谱的原创区块链毕设代做网站
部分资料来自网络,侵权联系删除!
资源收费仅为搬运整理打赏费用,用户自愿支付 !
qklbishe.com区块链毕设代做网专注|以太坊fabric-计算机|java|毕业设计|代做平台 » 山丘i资料

提供最优质的资源集合

立即查看 了解详情